# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.7
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.





from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_CosmoBolognaLib', [dirname(__file__)])
        except ImportError:
            import _CosmoBolognaLib
            return _CosmoBolognaLib
        if fp is not None:
            try:
                _mod = imp.load_module('_CosmoBolognaLib', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _CosmoBolognaLib = swig_import_helper()
    del swig_import_helper
else:
    import _CosmoBolognaLib
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0


class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        return _CosmoBolognaLib.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _CosmoBolognaLib.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _CosmoBolognaLib.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _CosmoBolognaLib.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _CosmoBolognaLib.SwigPyIterator_equal(self, x)

    def copy(self):
        return _CosmoBolognaLib.SwigPyIterator_copy(self)

    def next(self):
        return _CosmoBolognaLib.SwigPyIterator_next(self)

    def __next__(self):
        return _CosmoBolognaLib.SwigPyIterator___next__(self)

    def previous(self):
        return _CosmoBolognaLib.SwigPyIterator_previous(self)

    def advance(self, n):
        return _CosmoBolognaLib.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _CosmoBolognaLib.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _CosmoBolognaLib.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _CosmoBolognaLib.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _CosmoBolognaLib.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _CosmoBolognaLib.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _CosmoBolognaLib.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _CosmoBolognaLib.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)


_CosmoBolognaLib.SHARED_PTR_DISOWN_swigconstant(_CosmoBolognaLib)
SHARED_PTR_DISOWN = _CosmoBolognaLib.SHARED_PTR_DISOWN

_CosmoBolognaLib._1D__swigconstant(_CosmoBolognaLib)
_1D_ = _CosmoBolognaLib._1D_

_CosmoBolognaLib._2D__swigconstant(_CosmoBolognaLib)
_2D_ = _CosmoBolognaLib._2D_

_CosmoBolognaLib._linear__swigconstant(_CosmoBolognaLib)
_linear_ = _CosmoBolognaLib._linear_

_CosmoBolognaLib._logarithmic__swigconstant(_CosmoBolognaLib)
_logarithmic_ = _CosmoBolognaLib._logarithmic_

_CosmoBolognaLib._radians__swigconstant(_CosmoBolognaLib)
_radians_ = _CosmoBolognaLib._radians_

_CosmoBolognaLib._degrees__swigconstant(_CosmoBolognaLib)
_degrees_ = _CosmoBolognaLib._degrees_

_CosmoBolognaLib._arcseconds__swigconstant(_CosmoBolognaLib)
_arcseconds_ = _CosmoBolognaLib._arcseconds_

_CosmoBolognaLib._arcminutes__swigconstant(_CosmoBolognaLib)
_arcminutes_ = _CosmoBolognaLib._arcminutes_

_CosmoBolognaLib._comovingCoordinates__swigconstant(_CosmoBolognaLib)
_comovingCoordinates_ = _CosmoBolognaLib._comovingCoordinates_

_CosmoBolognaLib._observedCoordinates__swigconstant(_CosmoBolognaLib)
_observedCoordinates_ = _CosmoBolognaLib._observedCoordinates_
class comovingCoordinates(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, comovingCoordinates, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, comovingCoordinates, name)
    __repr__ = _swig_repr
    __swig_setmethods__["xx"] = _CosmoBolognaLib.comovingCoordinates_xx_set
    __swig_getmethods__["xx"] = _CosmoBolognaLib.comovingCoordinates_xx_get
    if _newclass:
        xx = _swig_property(_CosmoBolognaLib.comovingCoordinates_xx_get, _CosmoBolognaLib.comovingCoordinates_xx_set)
    __swig_setmethods__["yy"] = _CosmoBolognaLib.comovingCoordinates_yy_set
    __swig_getmethods__["yy"] = _CosmoBolognaLib.comovingCoordinates_yy_get
    if _newclass:
        yy = _swig_property(_CosmoBolognaLib.comovingCoordinates_yy_get, _CosmoBolognaLib.comovingCoordinates_yy_set)
    __swig_setmethods__["zz"] = _CosmoBolognaLib.comovingCoordinates_zz_set
    __swig_getmethods__["zz"] = _CosmoBolognaLib.comovingCoordinates_zz_get
    if _newclass:
        zz = _swig_property(_CosmoBolognaLib.comovingCoordinates_zz_get, _CosmoBolognaLib.comovingCoordinates_zz_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_comovingCoordinates()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_comovingCoordinates
    __del__ = lambda self: None
comovingCoordinates_swigregister = _CosmoBolognaLib.comovingCoordinates_swigregister
comovingCoordinates_swigregister(comovingCoordinates)

class observedCoordinates(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, observedCoordinates, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, observedCoordinates, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ra"] = _CosmoBolognaLib.observedCoordinates_ra_set
    __swig_getmethods__["ra"] = _CosmoBolognaLib.observedCoordinates_ra_get
    if _newclass:
        ra = _swig_property(_CosmoBolognaLib.observedCoordinates_ra_get, _CosmoBolognaLib.observedCoordinates_ra_set)
    __swig_setmethods__["dec"] = _CosmoBolognaLib.observedCoordinates_dec_set
    __swig_getmethods__["dec"] = _CosmoBolognaLib.observedCoordinates_dec_get
    if _newclass:
        dec = _swig_property(_CosmoBolognaLib.observedCoordinates_dec_get, _CosmoBolognaLib.observedCoordinates_dec_set)
    __swig_setmethods__["redshift"] = _CosmoBolognaLib.observedCoordinates_redshift_set
    __swig_getmethods__["redshift"] = _CosmoBolognaLib.observedCoordinates_redshift_get
    if _newclass:
        redshift = _swig_property(_CosmoBolognaLib.observedCoordinates_redshift_get, _CosmoBolognaLib.observedCoordinates_redshift_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_observedCoordinates()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_observedCoordinates
    __del__ = lambda self: None
observedCoordinates_swigregister = _CosmoBolognaLib.observedCoordinates_swigregister
observedCoordinates_swigregister(observedCoordinates)


def headerCBL(stream):
    return _CosmoBolognaLib.headerCBL(stream)
headerCBL = _CosmoBolognaLib.headerCBL

def WarningMsg(msg):
    return _CosmoBolognaLib.WarningMsg(msg)
WarningMsg = _CosmoBolognaLib.WarningMsg

def Error(*args):
    return _CosmoBolognaLib.Error(*args)
Error = _CosmoBolognaLib.Error

def ErrorCBL(*args):
    return _CosmoBolognaLib.ErrorCBL(*args)
ErrorCBL = _CosmoBolognaLib.ErrorCBL

def Beep():
    return _CosmoBolognaLib.Beep()
Beep = _CosmoBolognaLib.Beep

def isSet(*args):
    return _CosmoBolognaLib.isSet(*args)
isSet = _CosmoBolognaLib.isSet

def ShortSwap(arg1):
    return _CosmoBolognaLib.ShortSwap(arg1)
ShortSwap = _CosmoBolognaLib.ShortSwap

def IntSwap(arg1):
    return _CosmoBolognaLib.IntSwap(arg1)
IntSwap = _CosmoBolognaLib.IntSwap

def LongSwap(arg1):
    return _CosmoBolognaLib.LongSwap(arg1)
LongSwap = _CosmoBolognaLib.LongSwap

def FloatSwap(arg1):
    return _CosmoBolognaLib.FloatSwap(arg1)
FloatSwap = _CosmoBolognaLib.FloatSwap

def DoubleSwap(arg1):
    return _CosmoBolognaLib.DoubleSwap(arg1)
DoubleSwap = _CosmoBolognaLib.DoubleSwap

def interpolated(_xx, xx, yy, type):
    return _CosmoBolognaLib.interpolated(_xx, xx, yy, type)
interpolated = _CosmoBolognaLib.interpolated

def interpolated_2D(_x1, _x2, x1, x2, yy, type):
    return _CosmoBolognaLib.interpolated_2D(_x1, _x2, x1, x2, yy, type)
interpolated_2D = _CosmoBolognaLib.interpolated_2D

def checkIO(*args):
    return _CosmoBolognaLib.checkIO(*args)
checkIO = _CosmoBolognaLib.checkIO

def convert_map_gnuplot_sm(file_gnu, file_sm):
    return _CosmoBolognaLib.convert_map_gnuplot_sm(file_gnu, file_sm)
convert_map_gnuplot_sm = _CosmoBolognaLib.convert_map_gnuplot_sm

def set_EnvVar(Var):
    return _CosmoBolognaLib.set_EnvVar(Var)
set_EnvVar = _CosmoBolognaLib.set_EnvVar

def check_EnvVar(Var):
    return _CosmoBolognaLib.check_EnvVar(Var)
check_EnvVar = _CosmoBolognaLib.check_EnvVar

def used_memory(type):
    return _CosmoBolognaLib.used_memory(type)
used_memory = _CosmoBolognaLib.used_memory

def check_memory(*args):
    return _CosmoBolognaLib.check_memory(*args)
check_memory = _CosmoBolognaLib.check_memory

def fullpath(path, isDir=1):
    return _CosmoBolognaLib.fullpath(path, isDir)
fullpath = _CosmoBolognaLib.fullpath

def Filter(r, rc):
    return _CosmoBolognaLib.Filter(r, rc)
Filter = _CosmoBolognaLib.Filter

def legendre_polynomial(mu, l):
    return _CosmoBolognaLib.legendre_polynomial(mu, l)
legendre_polynomial = _CosmoBolognaLib.legendre_polynomial

def legendre_polynomial_integral(mu, params):
    return _CosmoBolognaLib.legendre_polynomial_integral(mu, params)
legendre_polynomial_integral = _CosmoBolognaLib.legendre_polynomial_integral

def Legendre_polynomial_mu_average(ll, mu, delta_mu):
    return _CosmoBolognaLib.Legendre_polynomial_mu_average(ll, mu, delta_mu)
Legendre_polynomial_mu_average = _CosmoBolognaLib.Legendre_polynomial_mu_average

def j0(xx):
    return _CosmoBolognaLib.j0(xx)
j0 = _CosmoBolognaLib.j0

def j2(xx):
    return _CosmoBolognaLib.j2(xx)
j2 = _CosmoBolognaLib.j2

def j4(xx):
    return _CosmoBolognaLib.j4(xx)
j4 = _CosmoBolognaLib.j4

def jl(xx, order):
    return _CosmoBolognaLib.jl(xx, order)
jl = _CosmoBolognaLib.jl

def j0_distance_average(kk, r_down, r_up):
    return _CosmoBolognaLib.j0_distance_average(kk, r_down, r_up)
j0_distance_average = _CosmoBolognaLib.j0_distance_average

def j2_distance_average(kk, r_down, r_up):
    return _CosmoBolognaLib.j2_distance_average(kk, r_down, r_up)
j2_distance_average = _CosmoBolognaLib.j2_distance_average

def jl_spherical_integrand(rr, params):
    return _CosmoBolognaLib.jl_spherical_integrand(rr, params)
jl_spherical_integrand = _CosmoBolognaLib.jl_spherical_integrand

def jl_distance_average(kk, order, r_down, r_up):
    return _CosmoBolognaLib.jl_distance_average(kk, order, r_down, r_up)
jl_distance_average = _CosmoBolognaLib.jl_distance_average

def trapezoid_integration(xx, yy):
    return _CosmoBolognaLib.trapezoid_integration(xx, yy)
trapezoid_integration = _CosmoBolognaLib.trapezoid_integration

def GSL_integrate_qag(*args):
    return _CosmoBolognaLib.GSL_integrate_qag(*args)
GSL_integrate_qag = _CosmoBolognaLib.GSL_integrate_qag

def GSL_integrate_qagiu(*args):
    return _CosmoBolognaLib.GSL_integrate_qagiu(*args)
GSL_integrate_qagiu = _CosmoBolognaLib.GSL_integrate_qagiu

def GSL_integrate_qaws(*args):
    return _CosmoBolognaLib.GSL_integrate_qaws(*args)
GSL_integrate_qaws = _CosmoBolognaLib.GSL_integrate_qaws

def generic_integrand(xx, params):
    return _CosmoBolognaLib.generic_integrand(xx, params)
generic_integrand = _CosmoBolognaLib.generic_integrand

def generic_roots(xx, params):
    return _CosmoBolognaLib.generic_roots(xx, params)
generic_roots = _CosmoBolognaLib.generic_roots

def GSL_brent(*args):
    return _CosmoBolognaLib.GSL_brent(*args)
GSL_brent = _CosmoBolognaLib.GSL_brent

def gauleg(arg1, arg2, arg3, arg4, arg5):
    return _CosmoBolognaLib.gauleg(arg1, arg2, arg3, arg4, arg5)
gauleg = _CosmoBolognaLib.gauleg

def unique_unsorted(*args):
    return _CosmoBolognaLib.unique_unsorted(*args)
unique_unsorted = _CosmoBolognaLib.unique_unsorted
class CL(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["VV"] = _CosmoBolognaLib.CL_VV_set
    __swig_getmethods__["VV"] = _CosmoBolognaLib.CL_VV_get
    if _newclass:
        VV = _swig_property(_CosmoBolognaLib.CL_VV_get, _CosmoBolognaLib.CL_VV_set)

    def __init__(self, vv):
        this = _CosmoBolognaLib.new_CL(vv)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_CL
    __del__ = lambda self: None
CL_swigregister = _CosmoBolognaLib.CL_swigregister
CL_swigregister(CL)


def __lt__(arg1, arg2):
    return _CosmoBolognaLib.__lt__(arg1, arg2)
__lt__ = _CosmoBolognaLib.__lt__

def sort_2vectors(arg1, arg2, arg3):
    return _CosmoBolognaLib.sort_2vectors(arg1, arg2, arg3)
sort_2vectors = _CosmoBolognaLib.sort_2vectors

def sort_3vectors(arg1, arg2, arg3, arg4):
    return _CosmoBolognaLib.sort_3vectors(arg1, arg2, arg3, arg4)
sort_3vectors = _CosmoBolognaLib.sort_3vectors

def sort_4vectors(arg1, arg2, arg3, arg4, arg5):
    return _CosmoBolognaLib.sort_4vectors(arg1, arg2, arg3, arg4, arg5)
sort_4vectors = _CosmoBolognaLib.sort_4vectors

def __mul__(Mat1, Mat2):
    return _CosmoBolognaLib.__mul__(Mat1, Mat2)
__mul__ = _CosmoBolognaLib.__mul__

def invert_matrix(*args):
    return _CosmoBolognaLib.invert_matrix(*args)
invert_matrix = _CosmoBolognaLib.invert_matrix

def covariance_matrix(*args):
    return _CosmoBolognaLib.covariance_matrix(*args)
covariance_matrix = _CosmoBolognaLib.covariance_matrix

def read_cov(arg1, arg2, arg3, arg4, arg5):
    return _CosmoBolognaLib.read_cov(arg1, arg2, arg3, arg4, arg5)
read_cov = _CosmoBolognaLib.read_cov

def fill_distr(arg1, arg2, arg3, arg4, arg5, arg6, arg7):
    return _CosmoBolognaLib.fill_distr(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
fill_distr = _CosmoBolognaLib.fill_distr

def find_index(arg1, arg2, arg3, arg4, arg5):
    return _CosmoBolognaLib.find_index(arg1, arg2, arg3, arg4, arg5)
find_index = _CosmoBolognaLib.find_index

def generate_correlated_data(*args):
    return _CosmoBolognaLib.generate_correlated_data(*args)
generate_correlated_data = _CosmoBolognaLib.generate_correlated_data

def Moment(arg1, arg2, arg3, arg4, arg5, arg6, arg7):
    return _CosmoBolognaLib.Moment(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
Moment = _CosmoBolognaLib.Moment

def linearfit(xx):
    return _CosmoBolognaLib.linearfit(xx)
linearfit = _CosmoBolognaLib.linearfit

def quadratic(xx):
    return _CosmoBolognaLib.quadratic(xx)
quadratic = _CosmoBolognaLib.quadratic

def cubicfit(xx):
    return _CosmoBolognaLib.cubicfit(xx)
cubicfit = _CosmoBolognaLib.cubicfit

def closest_probability(xx, pp, par):
    return _CosmoBolognaLib.closest_probability(xx, pp, par)
closest_probability = _CosmoBolognaLib.closest_probability

def measure_var_function(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8):
    return _CosmoBolognaLib.measure_var_function(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
measure_var_function = _CosmoBolognaLib.measure_var_function

def distribution(*args):
    return _CosmoBolognaLib.distribution(*args)
distribution = _CosmoBolognaLib.distribution

def MC_Int(*args):
    return _CosmoBolognaLib.MC_Int(*args)
MC_Int = _CosmoBolognaLib.MC_Int

def bin_function(arg1, func, arg3, arg4, arg5, arg6, arg7, arg8, arg9):
    return _CosmoBolognaLib.bin_function(arg1, func, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
bin_function = _CosmoBolognaLib.bin_function

def bin_function_2D(arg1, func, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12):
    return _CosmoBolognaLib.bin_function_2D(arg1, func, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12)
bin_function_2D = _CosmoBolognaLib.bin_function_2D

def func_grid_lin(arg1, arg2):
    return _CosmoBolognaLib.func_grid_lin(arg1, arg2)
func_grid_lin = _CosmoBolognaLib.func_grid_lin

def func_grid_loglin(arg1, arg2):
    return _CosmoBolognaLib.func_grid_loglin(arg1, arg2)
func_grid_loglin = _CosmoBolognaLib.func_grid_loglin

def func_grid_log(arg1, arg2):
    return _CosmoBolognaLib.func_grid_log(arg1, arg2)
func_grid_log = _CosmoBolognaLib.func_grid_log

def func_grid_lin_2D(arg1, arg2, arg3):
    return _CosmoBolognaLib.func_grid_lin_2D(arg1, arg2, arg3)
func_grid_lin_2D = _CosmoBolognaLib.func_grid_lin_2D

def func_grid_loglin_2D(arg1, arg2, arg3):
    return _CosmoBolognaLib.func_grid_loglin_2D(arg1, arg2, arg3)
func_grid_loglin_2D = _CosmoBolognaLib.func_grid_loglin_2D

def func_grid_log_2D(arg1, arg2, arg3):
    return _CosmoBolognaLib.func_grid_log_2D(arg1, arg2, arg3)
func_grid_log_2D = _CosmoBolognaLib.func_grid_log_2D

def convolution(f1, f2, res, deltaX):
    return _CosmoBolognaLib.convolution(f1, f2, res, deltaX)
convolution = _CosmoBolognaLib.convolution

def degrees(*args):
    return _CosmoBolognaLib.degrees(*args)
degrees = _CosmoBolognaLib.degrees

def radians(*args):
    return _CosmoBolognaLib.radians(*args)
radians = _CosmoBolognaLib.radians

def arcseconds(*args):
    return _CosmoBolognaLib.arcseconds(*args)
arcseconds = _CosmoBolognaLib.arcseconds

def arcminutes(*args):
    return _CosmoBolognaLib.arcminutes(*args)
arcminutes = _CosmoBolognaLib.arcminutes

def converted_angle(*args):
    return _CosmoBolognaLib.converted_angle(*args)
converted_angle = _CosmoBolognaLib.converted_angle

def polar_coord(*args):
    return _CosmoBolognaLib.polar_coord(*args)
polar_coord = _CosmoBolognaLib.polar_coord

def cartesian_coord(*args):
    return _CosmoBolognaLib.cartesian_coord(*args)
cartesian_coord = _CosmoBolognaLib.cartesian_coord

def Euclidean_distance(x1, x2, y1, y2, z1, z2):
    return _CosmoBolognaLib.Euclidean_distance(x1, x2, y1, y2, z1, z2)
Euclidean_distance = _CosmoBolognaLib.Euclidean_distance

def perpendicular_distance(ra1, ra2, dec1, dec2, d1, d2):
    return _CosmoBolognaLib.perpendicular_distance(ra1, ra2, dec1, dec2, d1, d2)
perpendicular_distance = _CosmoBolognaLib.perpendicular_distance

def angular_distance(x1, x2, y1, y2, z1, z2):
    return _CosmoBolognaLib.angular_distance(x1, x2, y1, y2, z1, z2)
angular_distance = _CosmoBolognaLib.angular_distance

def haversine_distance(ra1, ra2, dec1, dec2):
    return _CosmoBolognaLib.haversine_distance(ra1, ra2, dec1, dec2)
haversine_distance = _CosmoBolognaLib.haversine_distance

def eq2sdss(arg1, arg2, arg3, arg4):
    return _CosmoBolognaLib.eq2sdss(arg1, arg2, arg3, arg4)
eq2sdss = _CosmoBolognaLib.eq2sdss

def sdss2eq(arg1, arg2, arg3, arg4):
    return _CosmoBolognaLib.sdss2eq(arg1, arg2, arg3, arg4)
sdss2eq = _CosmoBolognaLib.sdss2eq

def sdss_stripe(arg1, arg2, arg3, arg4):
    return _CosmoBolognaLib.sdss_stripe(arg1, arg2, arg3, arg4)
sdss_stripe = _CosmoBolognaLib.sdss_stripe

def xi_from_Pk(*args):
    return _CosmoBolognaLib.xi_from_Pk(*args)
xi_from_Pk = _CosmoBolognaLib.xi_from_Pk

def Pk_from_xi(*args):
    return _CosmoBolognaLib.Pk_from_xi(*args)
Pk_from_xi = _CosmoBolognaLib.Pk_from_xi

def func_xi_GSL(arg1, arg2):
    return _CosmoBolognaLib.func_xi_GSL(arg1, arg2)
func_xi_GSL = _CosmoBolognaLib.func_xi_GSL

def func_SSM_GSL(arg1, arg2):
    return _CosmoBolognaLib.func_SSM_GSL(arg1, arg2)
func_SSM_GSL = _CosmoBolognaLib.func_SSM_GSL

def wp(*args):
    return _CosmoBolognaLib.wp(*args)
wp = _CosmoBolognaLib.wp

def sigmaR(arg1, arg2, arg3, arg4):
    return _CosmoBolognaLib.sigmaR(arg1, arg2, arg3, arg4)
sigmaR = _CosmoBolognaLib.sigmaR

def xi_projected_powerlaw(arg1, arg2, arg3):
    return _CosmoBolognaLib.xi_projected_powerlaw(arg1, arg2, arg3)
xi_projected_powerlaw = _CosmoBolognaLib.xi_projected_powerlaw

def xi_ratio(*args):
    return _CosmoBolognaLib.xi_ratio(*args)
xi_ratio = _CosmoBolognaLib.xi_ratio

def error_xi_ratio(arg1, arg2):
    return _CosmoBolognaLib.error_xi_ratio(arg1, arg2)
error_xi_ratio = _CosmoBolognaLib.error_xi_ratio

def barred_xi_direct(arg1, arg2, arg3, rAPP=0., r0=-1., gamma=1.):
    return _CosmoBolognaLib.barred_xi_direct(arg1, arg2, arg3, rAPP, r0, gamma)
barred_xi_direct = _CosmoBolognaLib.barred_xi_direct

def barred_xi__direct(arg1, arg2, arg3, rAPP=0., r0=-1., gamma=1.):
    return _CosmoBolognaLib.barred_xi__direct(arg1, arg2, arg3, rAPP, r0, gamma)
barred_xi__direct = _CosmoBolognaLib.barred_xi__direct

def barred_xi_(arg1, arg2, arg3, rAPP=0., r0=-1., gamma=1.):
    return _CosmoBolognaLib.barred_xi_(arg1, arg2, arg3, rAPP, r0, gamma)
barred_xi_ = _CosmoBolognaLib.barred_xi_

def barred_xi__(arg1, arg2, arg3, rAPP=0., r0=-1., gamma=1.):
    return _CosmoBolognaLib.barred_xi__(arg1, arg2, arg3, rAPP, r0, gamma)
barred_xi__ = _CosmoBolognaLib.barred_xi__

def multipole_xi0(*args):
    return _CosmoBolognaLib.multipole_xi0(*args)
multipole_xi0 = _CosmoBolognaLib.multipole_xi0

def multipole_xi2(*args):
    return _CosmoBolognaLib.multipole_xi2(*args)
multipole_xi2 = _CosmoBolognaLib.multipole_xi2

def multipole_xi4(*args):
    return _CosmoBolognaLib.multipole_xi4(*args)
multipole_xi4 = _CosmoBolognaLib.multipole_xi4

def error_multipole_xi0(*args):
    return _CosmoBolognaLib.error_multipole_xi0(*args)
error_multipole_xi0 = _CosmoBolognaLib.error_multipole_xi0

def error_multipole_xi2(*args):
    return _CosmoBolognaLib.error_multipole_xi2(*args)
error_multipole_xi2 = _CosmoBolognaLib.error_multipole_xi2

def error_multipole_xi4(*args):
    return _CosmoBolognaLib.error_multipole_xi4(*args)
error_multipole_xi4 = _CosmoBolognaLib.error_multipole_xi4

def multipoles(arg1, arg2, arg3):
    return _CosmoBolognaLib.multipoles(arg1, arg2, arg3)
multipoles = _CosmoBolognaLib.multipoles

def multipole_xi0_model(*args):
    return _CosmoBolognaLib.multipole_xi0_model(*args)
multipole_xi0_model = _CosmoBolognaLib.multipole_xi0_model

def multipole_xi2_model(arg1, arg2, arg3):
    return _CosmoBolognaLib.multipole_xi2_model(arg1, arg2, arg3)
multipole_xi2_model = _CosmoBolognaLib.multipole_xi2_model

def multipole_xi4_model(arg1, arg2, arg3, arg4):
    return _CosmoBolognaLib.multipole_xi4_model(arg1, arg2, arg3, arg4)
multipole_xi4_model = _CosmoBolognaLib.multipole_xi4_model

def xi2D_lin_model(*args):
    return _CosmoBolognaLib.xi2D_lin_model(*args)
xi2D_lin_model = _CosmoBolognaLib.xi2D_lin_model

def xi2D_model(*args):
    return _CosmoBolognaLib.xi2D_model(*args)
xi2D_model = _CosmoBolognaLib.xi2D_model

def f_v(*args):
    return _CosmoBolognaLib.f_v(*args)
f_v = _CosmoBolognaLib.f_v

def f_star(arg1, arg2, arg3):
    return _CosmoBolognaLib.f_star(arg1, arg2, arg3)
f_star = _CosmoBolognaLib.f_star

def b_nl(arg1, arg2, bB=10., bC=4.):
    return _CosmoBolognaLib.b_nl(arg1, arg2, bB, bC)
b_nl = _CosmoBolognaLib.b_nl

def relative_error_beta(arg1, arg2, arg3):
    return _CosmoBolognaLib.relative_error_beta(arg1, arg2, arg3)
relative_error_beta = _CosmoBolognaLib.relative_error_beta

def Pkl_Kaiser_integrand(mu, parameters):
    return _CosmoBolognaLib.Pkl_Kaiser_integrand(mu, parameters)
Pkl_Kaiser_integrand = _CosmoBolognaLib.Pkl_Kaiser_integrand

def sigma2_integrand(mu, parameters):
    return _CosmoBolognaLib.sigma2_integrand(mu, parameters)
sigma2_integrand = _CosmoBolognaLib.sigma2_integrand

def covariance_XiMultipoles_integrand(kk, parameters):
    return _CosmoBolognaLib.covariance_XiMultipoles_integrand(kk, parameters)
covariance_XiMultipoles_integrand = _CosmoBolognaLib.covariance_XiMultipoles_integrand

def XiMultipoles_integrand(kk, parameters):
    return _CosmoBolognaLib.XiMultipoles_integrand(kk, parameters)
XiMultipoles_integrand = _CosmoBolognaLib.XiMultipoles_integrand

def XiMultipoles_from_Xi2D_integrand(mu, parameters):
    return _CosmoBolognaLib.XiMultipoles_from_Xi2D_integrand(mu, parameters)
XiMultipoles_from_Xi2D_integrand = _CosmoBolognaLib.XiMultipoles_from_Xi2D_integrand

def Pkl_Kaiser_integral(order, bias, f):
    return _CosmoBolognaLib.Pkl_Kaiser_integral(order, bias, f)
Pkl_Kaiser_integral = _CosmoBolognaLib.Pkl_Kaiser_integral

def Pk0_Kaiser(kk, Pk, bias, f):
    return _CosmoBolognaLib.Pk0_Kaiser(kk, Pk, bias, f)
Pk0_Kaiser = _CosmoBolognaLib.Pk0_Kaiser

def Pk2_Kaiser(kk, Pk, bias, f):
    return _CosmoBolognaLib.Pk2_Kaiser(kk, Pk, bias, f)
Pk2_Kaiser = _CosmoBolognaLib.Pk2_Kaiser

def Pk4_Kaiser(kk, Pk, bias, f):
    return _CosmoBolognaLib.Pk4_Kaiser(kk, Pk, bias, f)
Pk4_Kaiser = _CosmoBolognaLib.Pk4_Kaiser

def Pkl_Kaiser(orders, kk, Pk, bias, f):
    return _CosmoBolognaLib.Pkl_Kaiser(orders, kk, Pk, bias, f)
Pkl_Kaiser = _CosmoBolognaLib.Pkl_Kaiser

def Xi0(r, kk, Pk0, k_cut=0.7, cut_pow=2, IntegrationMethod=1):
    return _CosmoBolognaLib.Xi0(r, kk, Pk0, k_cut, cut_pow, IntegrationMethod)
Xi0 = _CosmoBolognaLib.Xi0

def Xi2(rr, kk, Pk2, k_cut=0.58, cut_pow=4, IntegrationMethod=1):
    return _CosmoBolognaLib.Xi2(rr, kk, Pk2, k_cut, cut_pow, IntegrationMethod)
Xi2 = _CosmoBolognaLib.Xi2

def Xi4(rr, kk, Pk4, k_cut=0.6, cut_pow=2, IntegrationMethod=1):
    return _CosmoBolognaLib.Xi4(rr, kk, Pk4, k_cut, cut_pow, IntegrationMethod)
Xi4 = _CosmoBolognaLib.Xi4

def Xi02_AP(alpha_perpendicular, alpha_parallel, rr, rl, Xi0, Xi2):
    return _CosmoBolognaLib.Xi02_AP(alpha_perpendicular, alpha_parallel, rr, rl, Xi0, Xi2)
Xi02_AP = _CosmoBolognaLib.Xi02_AP

def Xi024_AP(alpha_perpendicular, alpha_parallel, rr, rl, Xi0, Xi2, Xi4):
    return _CosmoBolognaLib.Xi024_AP(alpha_perpendicular, alpha_parallel, rr, rl, Xi0, Xi2, Xi4)
Xi024_AP = _CosmoBolognaLib.Xi024_AP

def XiWedges_AP(mu_min, delta_mu, alpha_perpendicular, alpha_parallel, rr, rl, Xi0, Xi2, Xi4):
    return _CosmoBolognaLib.XiWedges_AP(mu_min, delta_mu, alpha_perpendicular, alpha_parallel, rr, rl, Xi0, Xi2, Xi4)
XiWedges_AP = _CosmoBolognaLib.XiWedges_AP

def sigma2_k(nObjects, Volume, kk, Pk_multipoles, orders):
    return _CosmoBolognaLib.sigma2_k(nObjects, Volume, kk, Pk_multipoles, orders)
sigma2_k = _CosmoBolognaLib.sigma2_k

def Covariance_XiMultipoles(rr, covariance, nbins, rMin, rMax, nObjects, Volume, kk, Pk_multipoles, orders):
    return _CosmoBolognaLib.Covariance_XiMultipoles(rr, covariance, nbins, rMin, rMax, nObjects, Volume, kk, Pk_multipoles, orders)
Covariance_XiMultipoles = _CosmoBolognaLib.Covariance_XiMultipoles

def Covariance_XiWedges(rr, covariance, mu, delta_mu, nbins, rMin, rMax, nObjects, Volume, kk, Pk_multipoles, orders):
    return _CosmoBolognaLib.Covariance_XiWedges(rr, covariance, mu, delta_mu, nbins, rMin, rMax, nObjects, Volume, kk, Pk_multipoles, orders)
Covariance_XiWedges = _CosmoBolognaLib.Covariance_XiWedges
class STR_generic_integrand(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, STR_generic_integrand, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, STR_generic_integrand, name)
    __repr__ = _swig_repr
    __swig_setmethods__["f"] = _CosmoBolognaLib.STR_generic_integrand_f_set
    __swig_getmethods__["f"] = _CosmoBolognaLib.STR_generic_integrand_f_get
    if _newclass:
        f = _swig_property(_CosmoBolognaLib.STR_generic_integrand_f_get, _CosmoBolognaLib.STR_generic_integrand_f_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_STR_generic_integrand()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_STR_generic_integrand
    __del__ = lambda self: None
STR_generic_integrand_swigregister = _CosmoBolognaLib.STR_generic_integrand_swigregister
STR_generic_integrand_swigregister(STR_generic_integrand)

class STR_generic_roots(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, STR_generic_roots, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, STR_generic_roots, name)
    __repr__ = _swig_repr
    __swig_setmethods__["f"] = _CosmoBolognaLib.STR_generic_roots_f_set
    __swig_getmethods__["f"] = _CosmoBolognaLib.STR_generic_roots_f_get
    if _newclass:
        f = _swig_property(_CosmoBolognaLib.STR_generic_roots_f_get, _CosmoBolognaLib.STR_generic_roots_f_set)
    __swig_setmethods__["xx0"] = _CosmoBolognaLib.STR_generic_roots_xx0_set
    __swig_getmethods__["xx0"] = _CosmoBolognaLib.STR_generic_roots_xx0_get
    if _newclass:
        xx0 = _swig_property(_CosmoBolognaLib.STR_generic_roots_xx0_get, _CosmoBolognaLib.STR_generic_roots_xx0_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_STR_generic_roots()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_STR_generic_roots
    __del__ = lambda self: None
STR_generic_roots_swigregister = _CosmoBolognaLib.STR_generic_roots_swigregister
STR_generic_roots_swigregister(STR_generic_roots)

class STR_grid(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, STR_grid, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, STR_grid, name)
    __repr__ = _swig_repr
    __swig_setmethods__["_xx"] = _CosmoBolognaLib.STR_grid__xx_set
    __swig_getmethods__["_xx"] = _CosmoBolognaLib.STR_grid__xx_get
    if _newclass:
        _xx = _swig_property(_CosmoBolognaLib.STR_grid__xx_get, _CosmoBolognaLib.STR_grid__xx_set)
    __swig_setmethods__["_yy"] = _CosmoBolognaLib.STR_grid__yy_set
    __swig_getmethods__["_yy"] = _CosmoBolognaLib.STR_grid__yy_get
    if _newclass:
        _yy = _swig_property(_CosmoBolognaLib.STR_grid__yy_get, _CosmoBolognaLib.STR_grid__yy_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_STR_grid()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_STR_grid
    __del__ = lambda self: None
STR_grid_swigregister = _CosmoBolognaLib.STR_grid_swigregister
STR_grid_swigregister(STR_grid)

class STR_grid_2D(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, STR_grid_2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, STR_grid_2D, name)
    __repr__ = _swig_repr
    __swig_setmethods__["_xx1"] = _CosmoBolognaLib.STR_grid_2D__xx1_set
    __swig_getmethods__["_xx1"] = _CosmoBolognaLib.STR_grid_2D__xx1_get
    if _newclass:
        _xx1 = _swig_property(_CosmoBolognaLib.STR_grid_2D__xx1_get, _CosmoBolognaLib.STR_grid_2D__xx1_set)
    __swig_setmethods__["_xx2"] = _CosmoBolognaLib.STR_grid_2D__xx2_set
    __swig_getmethods__["_xx2"] = _CosmoBolognaLib.STR_grid_2D__xx2_get
    if _newclass:
        _xx2 = _swig_property(_CosmoBolognaLib.STR_grid_2D__xx2_get, _CosmoBolognaLib.STR_grid_2D__xx2_set)
    __swig_setmethods__["_yy"] = _CosmoBolognaLib.STR_grid_2D__yy_set
    __swig_getmethods__["_yy"] = _CosmoBolognaLib.STR_grid_2D__yy_get
    if _newclass:
        _yy = _swig_property(_CosmoBolognaLib.STR_grid_2D__yy_get, _CosmoBolognaLib.STR_grid_2D__yy_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_STR_grid_2D()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_STR_grid_2D
    __del__ = lambda self: None
STR_grid_2D_swigregister = _CosmoBolognaLib.STR_grid_2D_swigregister
STR_grid_2D_swigregister(STR_grid_2D)

class STR_xi0_model(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, STR_xi0_model, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, STR_xi0_model, name)
    __repr__ = _swig_repr
    __swig_setmethods__["bias_sigma8"] = _CosmoBolognaLib.STR_xi0_model_bias_sigma8_set
    __swig_getmethods__["bias_sigma8"] = _CosmoBolognaLib.STR_xi0_model_bias_sigma8_get
    if _newclass:
        bias_sigma8 = _swig_property(_CosmoBolognaLib.STR_xi0_model_bias_sigma8_get, _CosmoBolognaLib.STR_xi0_model_bias_sigma8_set)
    __swig_setmethods__["sigma8z"] = _CosmoBolognaLib.STR_xi0_model_sigma8z_set
    __swig_getmethods__["sigma8z"] = _CosmoBolognaLib.STR_xi0_model_sigma8z_get
    if _newclass:
        sigma8z = _swig_property(_CosmoBolognaLib.STR_xi0_model_sigma8z_get, _CosmoBolognaLib.STR_xi0_model_sigma8z_set)
    __swig_setmethods__["xi_DM"] = _CosmoBolognaLib.STR_xi0_model_xi_DM_set
    __swig_getmethods__["xi_DM"] = _CosmoBolognaLib.STR_xi0_model_xi_DM_get
    if _newclass:
        xi_DM = _swig_property(_CosmoBolognaLib.STR_xi0_model_xi_DM_get, _CosmoBolognaLib.STR_xi0_model_xi_DM_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_STR_xi0_model()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_STR_xi0_model
    __del__ = lambda self: None
STR_xi0_model_swigregister = _CosmoBolognaLib.STR_xi0_model_swigregister
STR_xi0_model_swigregister(STR_xi0_model)

class STR_xi2D_model(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, STR_xi2D_model, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, STR_xi2D_model, name)
    __repr__ = _swig_repr
    __swig_setmethods__["rp"] = _CosmoBolognaLib.STR_xi2D_model_rp_set
    __swig_getmethods__["rp"] = _CosmoBolognaLib.STR_xi2D_model_rp_get
    if _newclass:
        rp = _swig_property(_CosmoBolognaLib.STR_xi2D_model_rp_get, _CosmoBolognaLib.STR_xi2D_model_rp_set)
    __swig_setmethods__["pi"] = _CosmoBolognaLib.STR_xi2D_model_pi_set
    __swig_getmethods__["pi"] = _CosmoBolognaLib.STR_xi2D_model_pi_get
    if _newclass:
        pi = _swig_property(_CosmoBolognaLib.STR_xi2D_model_pi_get, _CosmoBolognaLib.STR_xi2D_model_pi_set)
    __swig_setmethods__["xi_real"] = _CosmoBolognaLib.STR_xi2D_model_xi_real_set
    __swig_getmethods__["xi_real"] = _CosmoBolognaLib.STR_xi2D_model_xi_real_get
    if _newclass:
        xi_real = _swig_property(_CosmoBolognaLib.STR_xi2D_model_xi_real_get, _CosmoBolognaLib.STR_xi2D_model_xi_real_set)
    __swig_setmethods__["xi_"] = _CosmoBolognaLib.STR_xi2D_model_xi__set
    __swig_getmethods__["xi_"] = _CosmoBolognaLib.STR_xi2D_model_xi__get
    if _newclass:
        xi_ = _swig_property(_CosmoBolognaLib.STR_xi2D_model_xi__get, _CosmoBolognaLib.STR_xi2D_model_xi__set)
    __swig_setmethods__["xi__"] = _CosmoBolognaLib.STR_xi2D_model_xi___set
    __swig_getmethods__["xi__"] = _CosmoBolognaLib.STR_xi2D_model_xi___get
    if _newclass:
        xi__ = _swig_property(_CosmoBolognaLib.STR_xi2D_model_xi___get, _CosmoBolognaLib.STR_xi2D_model_xi___set)
    __swig_setmethods__["P2"] = _CosmoBolognaLib.STR_xi2D_model_P2_set
    __swig_getmethods__["P2"] = _CosmoBolognaLib.STR_xi2D_model_P2_get
    if _newclass:
        P2 = _swig_property(_CosmoBolognaLib.STR_xi2D_model_P2_get, _CosmoBolognaLib.STR_xi2D_model_P2_set)
    __swig_setmethods__["P4"] = _CosmoBolognaLib.STR_xi2D_model_P4_set
    __swig_getmethods__["P4"] = _CosmoBolognaLib.STR_xi2D_model_P4_get
    if _newclass:
        P4 = _swig_property(_CosmoBolognaLib.STR_xi2D_model_P4_get, _CosmoBolognaLib.STR_xi2D_model_P4_set)
    __swig_setmethods__["vel"] = _CosmoBolognaLib.STR_xi2D_model_vel_set
    __swig_getmethods__["vel"] = _CosmoBolognaLib.STR_xi2D_model_vel_get
    if _newclass:
        vel = _swig_property(_CosmoBolognaLib.STR_xi2D_model_vel_get, _CosmoBolognaLib.STR_xi2D_model_vel_set)
    __swig_setmethods__["lim_index_fit"] = _CosmoBolognaLib.STR_xi2D_model_lim_index_fit_set
    __swig_getmethods__["lim_index_fit"] = _CosmoBolognaLib.STR_xi2D_model_lim_index_fit_get
    if _newclass:
        lim_index_fit = _swig_property(_CosmoBolognaLib.STR_xi2D_model_lim_index_fit_get, _CosmoBolognaLib.STR_xi2D_model_lim_index_fit_set)
    __swig_setmethods__["type"] = _CosmoBolognaLib.STR_xi2D_model_type_set
    __swig_getmethods__["type"] = _CosmoBolognaLib.STR_xi2D_model_type_get
    if _newclass:
        type = _swig_property(_CosmoBolognaLib.STR_xi2D_model_type_get, _CosmoBolognaLib.STR_xi2D_model_type_set)
    __swig_setmethods__["step_v"] = _CosmoBolognaLib.STR_xi2D_model_step_v_set
    __swig_getmethods__["step_v"] = _CosmoBolognaLib.STR_xi2D_model_step_v_get
    if _newclass:
        step_v = _swig_property(_CosmoBolognaLib.STR_xi2D_model_step_v_get, _CosmoBolognaLib.STR_xi2D_model_step_v_set)
    __swig_setmethods__["FV"] = _CosmoBolognaLib.STR_xi2D_model_FV_set
    __swig_getmethods__["FV"] = _CosmoBolognaLib.STR_xi2D_model_FV_get
    if _newclass:
        FV = _swig_property(_CosmoBolognaLib.STR_xi2D_model_FV_get, _CosmoBolognaLib.STR_xi2D_model_FV_set)
    __swig_setmethods__["dim"] = _CosmoBolognaLib.STR_xi2D_model_dim_set
    __swig_getmethods__["dim"] = _CosmoBolognaLib.STR_xi2D_model_dim_get
    if _newclass:
        dim = _swig_property(_CosmoBolognaLib.STR_xi2D_model_dim_get, _CosmoBolognaLib.STR_xi2D_model_dim_set)
    __swig_setmethods__["delta_v"] = _CosmoBolognaLib.STR_xi2D_model_delta_v_set
    __swig_getmethods__["delta_v"] = _CosmoBolognaLib.STR_xi2D_model_delta_v_get
    if _newclass:
        delta_v = _swig_property(_CosmoBolognaLib.STR_xi2D_model_delta_v_get, _CosmoBolognaLib.STR_xi2D_model_delta_v_set)
    __swig_setmethods__["bias_nl"] = _CosmoBolognaLib.STR_xi2D_model_bias_nl_set
    __swig_getmethods__["bias_nl"] = _CosmoBolognaLib.STR_xi2D_model_bias_nl_get
    if _newclass:
        bias_nl = _swig_property(_CosmoBolognaLib.STR_xi2D_model_bias_nl_get, _CosmoBolognaLib.STR_xi2D_model_bias_nl_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_STR_xi2D_model()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_STR_xi2D_model
    __del__ = lambda self: None
STR_xi2D_model_swigregister = _CosmoBolognaLib.STR_xi2D_model_swigregister
STR_xi2D_model_swigregister(STR_xi2D_model)

class STR_xi(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, STR_xi, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, STR_xi, name)
    __repr__ = _swig_repr
    __swig_setmethods__["rr"] = _CosmoBolognaLib.STR_xi_rr_set
    __swig_getmethods__["rr"] = _CosmoBolognaLib.STR_xi_rr_get
    if _newclass:
        rr = _swig_property(_CosmoBolognaLib.STR_xi_rr_get, _CosmoBolognaLib.STR_xi_rr_set)
    __swig_setmethods__["aa"] = _CosmoBolognaLib.STR_xi_aa_set
    __swig_getmethods__["aa"] = _CosmoBolognaLib.STR_xi_aa_get
    if _newclass:
        aa = _swig_property(_CosmoBolognaLib.STR_xi_aa_get, _CosmoBolognaLib.STR_xi_aa_set)
    __swig_setmethods__["lgkk"] = _CosmoBolognaLib.STR_xi_lgkk_set
    __swig_getmethods__["lgkk"] = _CosmoBolognaLib.STR_xi_lgkk_get
    if _newclass:
        lgkk = _swig_property(_CosmoBolognaLib.STR_xi_lgkk_get, _CosmoBolognaLib.STR_xi_lgkk_set)
    __swig_setmethods__["lgPk"] = _CosmoBolognaLib.STR_xi_lgPk_set
    __swig_getmethods__["lgPk"] = _CosmoBolognaLib.STR_xi_lgPk_get
    if _newclass:
        lgPk = _swig_property(_CosmoBolognaLib.STR_xi_lgPk_get, _CosmoBolognaLib.STR_xi_lgPk_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_STR_xi()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_STR_xi
    __del__ = lambda self: None
STR_xi_swigregister = _CosmoBolognaLib.STR_xi_swigregister
STR_xi_swigregister(STR_xi)

class STR_SSM(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, STR_SSM, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, STR_SSM, name)
    __repr__ = _swig_repr
    __swig_setmethods__["unit"] = _CosmoBolognaLib.STR_SSM_unit_set
    __swig_getmethods__["unit"] = _CosmoBolognaLib.STR_SSM_unit_get
    if _newclass:
        unit = _swig_property(_CosmoBolognaLib.STR_SSM_unit_get, _CosmoBolognaLib.STR_SSM_unit_set)
    __swig_setmethods__["hh"] = _CosmoBolognaLib.STR_SSM_hh_set
    __swig_getmethods__["hh"] = _CosmoBolognaLib.STR_SSM_hh_get
    if _newclass:
        hh = _swig_property(_CosmoBolognaLib.STR_SSM_hh_get, _CosmoBolognaLib.STR_SSM_hh_set)
    __swig_setmethods__["mass"] = _CosmoBolognaLib.STR_SSM_mass_set
    __swig_getmethods__["mass"] = _CosmoBolognaLib.STR_SSM_mass_get
    if _newclass:
        mass = _swig_property(_CosmoBolognaLib.STR_SSM_mass_get, _CosmoBolognaLib.STR_SSM_mass_set)
    __swig_setmethods__["rho"] = _CosmoBolognaLib.STR_SSM_rho_set
    __swig_getmethods__["rho"] = _CosmoBolognaLib.STR_SSM_rho_get
    if _newclass:
        rho = _swig_property(_CosmoBolognaLib.STR_SSM_rho_get, _CosmoBolognaLib.STR_SSM_rho_set)
    __swig_setmethods__["n_spec"] = _CosmoBolognaLib.STR_SSM_n_spec_set
    __swig_getmethods__["n_spec"] = _CosmoBolognaLib.STR_SSM_n_spec_get
    if _newclass:
        n_spec = _swig_property(_CosmoBolognaLib.STR_SSM_n_spec_get, _CosmoBolognaLib.STR_SSM_n_spec_set)
    __swig_setmethods__["lgkk"] = _CosmoBolognaLib.STR_SSM_lgkk_set
    __swig_getmethods__["lgkk"] = _CosmoBolognaLib.STR_SSM_lgkk_get
    if _newclass:
        lgkk = _swig_property(_CosmoBolognaLib.STR_SSM_lgkk_get, _CosmoBolognaLib.STR_SSM_lgkk_set)
    __swig_setmethods__["lgPk"] = _CosmoBolognaLib.STR_SSM_lgPk_set
    __swig_getmethods__["lgPk"] = _CosmoBolognaLib.STR_SSM_lgPk_get
    if _newclass:
        lgPk = _swig_property(_CosmoBolognaLib.STR_SSM_lgPk_get, _CosmoBolognaLib.STR_SSM_lgPk_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_STR_SSM()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_STR_SSM
    __del__ = lambda self: None
STR_SSM_swigregister = _CosmoBolognaLib.STR_SSM_swigregister
STR_SSM_swigregister(STR_SSM)

class STR_jl_distance_average(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, STR_jl_distance_average, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, STR_jl_distance_average, name)
    __repr__ = _swig_repr
    __swig_setmethods__["order"] = _CosmoBolognaLib.STR_jl_distance_average_order_set
    __swig_getmethods__["order"] = _CosmoBolognaLib.STR_jl_distance_average_order_get
    if _newclass:
        order = _swig_property(_CosmoBolognaLib.STR_jl_distance_average_order_get, _CosmoBolognaLib.STR_jl_distance_average_order_set)
    __swig_setmethods__["k"] = _CosmoBolognaLib.STR_jl_distance_average_k_set
    __swig_getmethods__["k"] = _CosmoBolognaLib.STR_jl_distance_average_k_get
    if _newclass:
        k = _swig_property(_CosmoBolognaLib.STR_jl_distance_average_k_get, _CosmoBolognaLib.STR_jl_distance_average_k_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_STR_jl_distance_average()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_STR_jl_distance_average
    __del__ = lambda self: None
STR_jl_distance_average_swigregister = _CosmoBolognaLib.STR_jl_distance_average_swigregister
STR_jl_distance_average_swigregister(STR_jl_distance_average)

class STR_Pl_mu_integral(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, STR_Pl_mu_integral, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, STR_Pl_mu_integral, name)
    __repr__ = _swig_repr
    __swig_setmethods__["order"] = _CosmoBolognaLib.STR_Pl_mu_integral_order_set
    __swig_getmethods__["order"] = _CosmoBolognaLib.STR_Pl_mu_integral_order_get
    if _newclass:
        order = _swig_property(_CosmoBolognaLib.STR_Pl_mu_integral_order_get, _CosmoBolognaLib.STR_Pl_mu_integral_order_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_STR_Pl_mu_integral()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_STR_Pl_mu_integral
    __del__ = lambda self: None
STR_Pl_mu_integral_swigregister = _CosmoBolognaLib.STR_Pl_mu_integral_swigregister
STR_Pl_mu_integral_swigregister(STR_Pl_mu_integral)

class STR_Pkl_Kaiser_integrand(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, STR_Pkl_Kaiser_integrand, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, STR_Pkl_Kaiser_integrand, name)
    __repr__ = _swig_repr
    __swig_setmethods__["l"] = _CosmoBolognaLib.STR_Pkl_Kaiser_integrand_l_set
    __swig_getmethods__["l"] = _CosmoBolognaLib.STR_Pkl_Kaiser_integrand_l_get
    if _newclass:
        l = _swig_property(_CosmoBolognaLib.STR_Pkl_Kaiser_integrand_l_get, _CosmoBolognaLib.STR_Pkl_Kaiser_integrand_l_set)
    __swig_setmethods__["Pk"] = _CosmoBolognaLib.STR_Pkl_Kaiser_integrand_Pk_set
    __swig_getmethods__["Pk"] = _CosmoBolognaLib.STR_Pkl_Kaiser_integrand_Pk_get
    if _newclass:
        Pk = _swig_property(_CosmoBolognaLib.STR_Pkl_Kaiser_integrand_Pk_get, _CosmoBolognaLib.STR_Pkl_Kaiser_integrand_Pk_set)
    __swig_setmethods__["bias"] = _CosmoBolognaLib.STR_Pkl_Kaiser_integrand_bias_set
    __swig_getmethods__["bias"] = _CosmoBolognaLib.STR_Pkl_Kaiser_integrand_bias_get
    if _newclass:
        bias = _swig_property(_CosmoBolognaLib.STR_Pkl_Kaiser_integrand_bias_get, _CosmoBolognaLib.STR_Pkl_Kaiser_integrand_bias_set)
    __swig_setmethods__["f"] = _CosmoBolognaLib.STR_Pkl_Kaiser_integrand_f_set
    __swig_getmethods__["f"] = _CosmoBolognaLib.STR_Pkl_Kaiser_integrand_f_get
    if _newclass:
        f = _swig_property(_CosmoBolognaLib.STR_Pkl_Kaiser_integrand_f_get, _CosmoBolognaLib.STR_Pkl_Kaiser_integrand_f_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_STR_Pkl_Kaiser_integrand()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_STR_Pkl_Kaiser_integrand
    __del__ = lambda self: None
STR_Pkl_Kaiser_integrand_swigregister = _CosmoBolognaLib.STR_Pkl_Kaiser_integrand_swigregister
STR_Pkl_Kaiser_integrand_swigregister(STR_Pkl_Kaiser_integrand)

class STR_closest_probability(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, STR_closest_probability, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, STR_closest_probability, name)
    __repr__ = _swig_repr
    __swig_setmethods__["values"] = _CosmoBolognaLib.STR_closest_probability_values_set
    __swig_getmethods__["values"] = _CosmoBolognaLib.STR_closest_probability_values_get
    if _newclass:
        values = _swig_property(_CosmoBolognaLib.STR_closest_probability_values_get, _CosmoBolognaLib.STR_closest_probability_values_set)
    __swig_setmethods__["weights"] = _CosmoBolognaLib.STR_closest_probability_weights_set
    __swig_getmethods__["weights"] = _CosmoBolognaLib.STR_closest_probability_weights_get
    if _newclass:
        weights = _swig_property(_CosmoBolognaLib.STR_closest_probability_weights_get, _CosmoBolognaLib.STR_closest_probability_weights_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_STR_closest_probability()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_STR_closest_probability
    __del__ = lambda self: None
STR_closest_probability_swigregister = _CosmoBolognaLib.STR_closest_probability_swigregister
STR_closest_probability_swigregister(STR_closest_probability)


_CosmoBolognaLib._1D_data__swigconstant(_CosmoBolognaLib)
_1D_data_ = _CosmoBolognaLib._1D_data_

_CosmoBolognaLib._2D_data__swigconstant(_CosmoBolognaLib)
_2D_data_ = _CosmoBolognaLib._2D_data_

_CosmoBolognaLib._1D_data_collection__swigconstant(_CosmoBolognaLib)
_1D_data_collection_ = _CosmoBolognaLib._1D_data_collection_

_CosmoBolognaLib._1D_data_extra__swigconstant(_CosmoBolognaLib)
_1D_data_extra_ = _CosmoBolognaLib._1D_data_extra_

_CosmoBolognaLib._2D_data_extra__swigconstant(_CosmoBolognaLib)
_2D_data_extra_ = _CosmoBolognaLib._2D_data_extra_
class Data(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Data, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Data, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Data(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Data
    __del__ = lambda self: None
    __swig_getmethods__["Create"] = lambda x: _CosmoBolognaLib.Data_Create
    if _newclass:
        Create = staticmethod(_CosmoBolognaLib.Data_Create)

    def dataType(self):
        return _CosmoBolognaLib.Data_dataType(self)

    def y_down(self):
        return _CosmoBolognaLib.Data_y_down(self)

    def y_up(self):
        return _CosmoBolognaLib.Data_y_up(self)

    def covariance(self, *args):
        return _CosmoBolognaLib.Data_covariance(self, *args)

    def inverse_covariance(self, *args):
        return _CosmoBolognaLib.Data_inverse_covariance(self, *args)

    def yy(self, *args):
        return _CosmoBolognaLib.Data_yy(self, *args)

    def fxy(self, *args):
        return _CosmoBolognaLib.Data_fxy(self, *args)

    def error_fxy(self, *args):
        return _CosmoBolognaLib.Data_error_fxy(self, *args)

    def x_down(self, *args):
        return _CosmoBolognaLib.Data_x_down(self, *args)

    def x_up(self, *args):
        return _CosmoBolognaLib.Data_x_up(self, *args)

    def xx(self, *args):
        return _CosmoBolognaLib.Data_xx(self, *args)

    def fx(self, *args):
        return _CosmoBolognaLib.Data_fx(self, *args)

    def error_fx(self, *args):
        return _CosmoBolognaLib.Data_error_fx(self, *args)

    def extra_info(self, *args):
        return _CosmoBolognaLib.Data_extra_info(self, *args)

    def set_dataType(self, dataType):
        return _CosmoBolognaLib.Data_set_dataType(self, dataType)

    def set_yy(self, y):
        return _CosmoBolognaLib.Data_set_yy(self, y)

    def set_fxy(self, fxy):
        return _CosmoBolognaLib.Data_set_fxy(self, fxy)

    def set_error_fxy(self, error_fxy):
        return _CosmoBolognaLib.Data_set_error_fxy(self, error_fxy)

    def set_limits(self, *args):
        return _CosmoBolognaLib.Data_set_limits(self, *args)

    def set_xx(self, *args):
        return _CosmoBolognaLib.Data_set_xx(self, *args)

    def set_fx(self, *args):
        return _CosmoBolognaLib.Data_set_fx(self, *args)

    def set_error_fx(self, *args):
        return _CosmoBolognaLib.Data_set_error_fx(self, *args)

    def set_covariance(self, *args):
        return _CosmoBolognaLib.Data_set_covariance(self, *args)

    def set_extra_info(self, extra_info):
        return _CosmoBolognaLib.Data_set_extra_info(self, extra_info)

    def ndata_eff(self, *args):
        return _CosmoBolognaLib.Data_ndata_eff(self, *args)

    def ndata(self, *args):
        return _CosmoBolognaLib.Data_ndata(self, *args)

    def ndataset(self):
        return _CosmoBolognaLib.Data_ndataset(self)

    def invert_covariance(self):
        return _CosmoBolognaLib.Data_invert_covariance(self)

    def read(self, input_file, skip_nlines=0):
        return _CosmoBolognaLib.Data_read(self, input_file, skip_nlines)

    def write(self, *args):
        return _CosmoBolognaLib.Data_write(self, *args)

    def write_covariance(self, *args):
        return _CosmoBolognaLib.Data_write_covariance(self, *args)
Data_swigregister = _CosmoBolognaLib.Data_swigregister
Data_swigregister(Data)

def Data_Create(*args):
    return _CosmoBolognaLib.Data_Create(*args)
Data_Create = _CosmoBolognaLib.Data_Create

class Data1D(Data):
    __swig_setmethods__ = {}
    for _s in [Data]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Data1D, name, value)
    __swig_getmethods__ = {}
    for _s in [Data]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Data1D, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Data1D(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Data1D
    __del__ = lambda self: None

    def x_down(self):
        return _CosmoBolognaLib.Data1D_x_down(self)

    def x_up(self):
        return _CosmoBolognaLib.Data1D_x_up(self)

    def xx(self, *args):
        return _CosmoBolognaLib.Data1D_xx(self, *args)

    def fx(self, *args):
        return _CosmoBolognaLib.Data1D_fx(self, *args)

    def error_fx(self, *args):
        return _CosmoBolognaLib.Data1D_error_fx(self, *args)

    def covariance(self, *args):
        return _CosmoBolognaLib.Data1D_covariance(self, *args)

    def inverse_covariance(self, *args):
        return _CosmoBolognaLib.Data1D_inverse_covariance(self, *args)

    def set_limits(self, xmin, xmax):
        return _CosmoBolognaLib.Data1D_set_limits(self, xmin, xmax)

    def set_xx(self, x):
        return _CosmoBolognaLib.Data1D_set_xx(self, x)

    def set_fx(self, fx):
        return _CosmoBolognaLib.Data1D_set_fx(self, fx)

    def set_error_fx(self, error_fx):
        return _CosmoBolognaLib.Data1D_set_error_fx(self, error_fx)

    def set_covariance(self, *args):
        return _CosmoBolognaLib.Data1D_set_covariance(self, *args)

    def ndata_eff(self):
        return _CosmoBolognaLib.Data1D_ndata_eff(self)

    def ndata(self):
        return _CosmoBolognaLib.Data1D_ndata(self)

    def invert_covariance(self):
        return _CosmoBolognaLib.Data1D_invert_covariance(self)

    def read(self, input_file, skip_nlines=0):
        return _CosmoBolognaLib.Data1D_read(self, input_file, skip_nlines)

    def write(self, dir, file, header, rank=0):
        return _CosmoBolognaLib.Data1D_write(self, dir, file, header, rank)

    def write_covariance(self, *args):
        return _CosmoBolognaLib.Data1D_write_covariance(self, *args)
Data1D_swigregister = _CosmoBolognaLib.Data1D_swigregister
Data1D_swigregister(Data1D)

class Data2D(Data):
    __swig_setmethods__ = {}
    for _s in [Data]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Data2D, name, value)
    __swig_getmethods__ = {}
    for _s in [Data]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Data2D, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Data2D(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Data2D
    __del__ = lambda self: None

    def x_down(self):
        return _CosmoBolognaLib.Data2D_x_down(self)

    def x_up(self):
        return _CosmoBolognaLib.Data2D_x_up(self)

    def y_down(self):
        return _CosmoBolognaLib.Data2D_y_down(self)

    def y_up(self):
        return _CosmoBolognaLib.Data2D_y_up(self)

    def covariance(self, i1, i2, j1, j2):
        return _CosmoBolognaLib.Data2D_covariance(self, i1, i2, j1, j2)

    def xx(self, *args):
        return _CosmoBolognaLib.Data2D_xx(self, *args)

    def yy(self, *args):
        return _CosmoBolognaLib.Data2D_yy(self, *args)

    def fxy(self, *args):
        return _CosmoBolognaLib.Data2D_fxy(self, *args)

    def error_fxy(self, *args):
        return _CosmoBolognaLib.Data2D_error_fxy(self, *args)

    def set_limits(self, *args):
        return _CosmoBolognaLib.Data2D_set_limits(self, *args)

    def set_xx(self, x):
        return _CosmoBolognaLib.Data2D_set_xx(self, x)

    def set_yy(self, y):
        return _CosmoBolognaLib.Data2D_set_yy(self, y)

    def set_fxy(self, fxy):
        return _CosmoBolognaLib.Data2D_set_fxy(self, fxy)

    def set_error_fxy(self, error_fxy):
        return _CosmoBolognaLib.Data2D_set_error_fxy(self, error_fxy)

    def ndata_eff(self):
        return _CosmoBolognaLib.Data2D_ndata_eff(self)

    def ndata(self):
        return _CosmoBolognaLib.Data2D_ndata(self)

    def read(self, input_file, skip_nlines=0):
        return _CosmoBolognaLib.Data2D_read(self, input_file, skip_nlines)

    def write(self, dir, file, header, full, rank=0):
        return _CosmoBolognaLib.Data2D_write(self, dir, file, header, full, rank)
Data2D_swigregister = _CosmoBolognaLib.Data2D_swigregister
Data2D_swigregister(Data2D)

class Field3D(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Field3D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Field3D, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Field3D(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Field3D
    __del__ = lambda self: None

    def set_parameters(self, *args):
        return _CosmoBolognaLib.Field3D_set_parameters(self, *args)

    def nx(self):
        return _CosmoBolognaLib.Field3D_nx(self)

    def ny(self):
        return _CosmoBolognaLib.Field3D_ny(self)

    def nz(self):
        return _CosmoBolognaLib.Field3D_nz(self)

    def nzFourier(self):
        return _CosmoBolognaLib.Field3D_nzFourier(self)

    def nCells(self):
        return _CosmoBolognaLib.Field3D_nCells(self)

    def nCellsFourier(self):
        return _CosmoBolognaLib.Field3D_nCellsFourier(self)

    def MinX(self):
        return _CosmoBolognaLib.Field3D_MinX(self)

    def MinY(self):
        return _CosmoBolognaLib.Field3D_MinY(self)

    def MinZ(self):
        return _CosmoBolognaLib.Field3D_MinZ(self)

    def MaxX(self):
        return _CosmoBolognaLib.Field3D_MaxX(self)

    def MaxY(self):
        return _CosmoBolognaLib.Field3D_MaxY(self)

    def MaxZ(self):
        return _CosmoBolognaLib.Field3D_MaxZ(self)

    def deltaX(self):
        return _CosmoBolognaLib.Field3D_deltaX(self)

    def deltaY(self):
        return _CosmoBolognaLib.Field3D_deltaY(self)

    def deltaZ(self):
        return _CosmoBolognaLib.Field3D_deltaZ(self)

    def Volume(self):
        return _CosmoBolognaLib.Field3D_Volume(self)

    def ScalarField(self, i, j, k):
        return _CosmoBolognaLib.Field3D_ScalarField(self, i, j, k)

    def VectorField(self, i, j, k):
        return _CosmoBolognaLib.Field3D_VectorField(self, i, j, k)

    def ScalarField_FourierSpace_real(self, i, j, k):
        return _CosmoBolognaLib.Field3D_ScalarField_FourierSpace_real(self, i, j, k)

    def ScalarField_FourierSpace_complex(self, i, j, k):
        return _CosmoBolognaLib.Field3D_ScalarField_FourierSpace_complex(self, i, j, k)

    def VectorField_FourierSpace_real(self, i, j, k):
        return _CosmoBolognaLib.Field3D_VectorField_FourierSpace_real(self, i, j, k)

    def VectorField_FourierSpace_complex(self, i, j, k):
        return _CosmoBolognaLib.Field3D_VectorField_FourierSpace_complex(self, i, j, k)

    def FourierTransformField(self):
        return _CosmoBolognaLib.Field3D_FourierTransformField(self)

    def FourierAntiTransformField(self):
        return _CosmoBolognaLib.Field3D_FourierAntiTransformField(self)

    def GaussianConvolutionField(self, kernel_size):
        return _CosmoBolognaLib.Field3D_GaussianConvolutionField(self, kernel_size)

    def set_ScalarField(self, value, i, j, k, add=0):
        return _CosmoBolognaLib.Field3D_set_ScalarField(self, value, i, j, k, add)

    def set_VectorField(self, value, i, j, k, add=0):
        return _CosmoBolognaLib.Field3D_set_VectorField(self, value, i, j, k, add)

    def set_ScalarField_FourierSpace_real(self, value, i, j, k, add=0):
        return _CosmoBolognaLib.Field3D_set_ScalarField_FourierSpace_real(self, value, i, j, k, add)

    def set_ScalarField_FourierSpace_complex(self, value, i, j, k, add=0):
        return _CosmoBolognaLib.Field3D_set_ScalarField_FourierSpace_complex(self, value, i, j, k, add)

    def set_VectorField_FourierSpace_real(self, value, i, j, k, add=0):
        return _CosmoBolognaLib.Field3D_set_VectorField_FourierSpace_real(self, value, i, j, k, add)

    def set_VectorField_FourierSpace_complex(self, value, i, j, k, add=0):
        return _CosmoBolognaLib.Field3D_set_VectorField_FourierSpace_complex(self, value, i, j, k, add)
Field3D_swigregister = _CosmoBolognaLib.Field3D_swigregister
Field3D_swigregister(Field3D)

class ScalarField3D(Field3D):
    __swig_setmethods__ = {}
    for _s in [Field3D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScalarField3D, name, value)
    __swig_getmethods__ = {}
    for _s in [Field3D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScalarField3D, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_ScalarField3D(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_ScalarField3D
    __del__ = lambda self: None

    def set_ScalarField(self, value, i, j, k, add=0):
        return _CosmoBolognaLib.ScalarField3D_set_ScalarField(self, value, i, j, k, add)

    def set_ScalarField_FourierSpace_real(self, value, i, j, k, add=0):
        return _CosmoBolognaLib.ScalarField3D_set_ScalarField_FourierSpace_real(self, value, i, j, k, add)

    def set_ScalarField_FourierSpace_complex(self, value, i, j, k, add=0):
        return _CosmoBolognaLib.ScalarField3D_set_ScalarField_FourierSpace_complex(self, value, i, j, k, add)

    def ScalarField(self, i, j, k):
        return _CosmoBolognaLib.ScalarField3D_ScalarField(self, i, j, k)

    def ScalarField_FourierSpace_real(self, i, j, k):
        return _CosmoBolognaLib.ScalarField3D_ScalarField_FourierSpace_real(self, i, j, k)

    def ScalarField_FourierSpace_complex(self, i, j, k):
        return _CosmoBolognaLib.ScalarField3D_ScalarField_FourierSpace_complex(self, i, j, k)

    def FourierTransformField(self):
        return _CosmoBolognaLib.ScalarField3D_FourierTransformField(self)

    def FourierAntiTransformField(self):
        return _CosmoBolognaLib.ScalarField3D_FourierAntiTransformField(self)

    def GaussianConvolutionField(self, kernel_size):
        return _CosmoBolognaLib.ScalarField3D_GaussianConvolutionField(self, kernel_size)
ScalarField3D_swigregister = _CosmoBolognaLib.ScalarField3D_swigregister
ScalarField3D_swigregister(ScalarField3D)

class VectorField3D(Field3D):
    __swig_setmethods__ = {}
    for _s in [Field3D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorField3D, name, value)
    __swig_getmethods__ = {}
    for _s in [Field3D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, VectorField3D, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_VectorField3D(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_VectorField3D
    __del__ = lambda self: None

    def set_VectorField(self, value, i, j, k, add=0):
        return _CosmoBolognaLib.VectorField3D_set_VectorField(self, value, i, j, k, add)

    def set_VectorField_FourierSpace_real(self, value, i, j, k, add=0):
        return _CosmoBolognaLib.VectorField3D_set_VectorField_FourierSpace_real(self, value, i, j, k, add)

    def set_VectorField_FourierSpace_complex(self, value, i, j, k, add=0):
        return _CosmoBolognaLib.VectorField3D_set_VectorField_FourierSpace_complex(self, value, i, j, k, add)

    def VectorField(self, i, j, k):
        return _CosmoBolognaLib.VectorField3D_VectorField(self, i, j, k)

    def VectorField_FourierSpace_real(self, i, j, k):
        return _CosmoBolognaLib.VectorField3D_VectorField_FourierSpace_real(self, i, j, k)

    def VectorField_FourierSpace_complex(self, i, j, k):
        return _CosmoBolognaLib.VectorField3D_VectorField_FourierSpace_complex(self, i, j, k)

    def FourierTransformField(self):
        return _CosmoBolognaLib.VectorField3D_FourierTransformField(self)

    def FourierAntiTransformField(self):
        return _CosmoBolognaLib.VectorField3D_FourierAntiTransformField(self)
VectorField3D_swigregister = _CosmoBolognaLib.VectorField3D_swigregister
VectorField3D_swigregister(VectorField3D)

class IntVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CosmoBolognaLib.IntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CosmoBolognaLib.IntVector___nonzero__(self)

    def __bool__(self):
        return _CosmoBolognaLib.IntVector___bool__(self)

    def __len__(self):
        return _CosmoBolognaLib.IntVector___len__(self)

    def pop(self):
        return _CosmoBolognaLib.IntVector_pop(self)

    def __getslice__(self, i, j):
        return _CosmoBolognaLib.IntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _CosmoBolognaLib.IntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _CosmoBolognaLib.IntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _CosmoBolognaLib.IntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _CosmoBolognaLib.IntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _CosmoBolognaLib.IntVector___setitem__(self, *args)

    def append(self, x):
        return _CosmoBolognaLib.IntVector_append(self, x)

    def empty(self):
        return _CosmoBolognaLib.IntVector_empty(self)

    def size(self):
        return _CosmoBolognaLib.IntVector_size(self)

    def clear(self):
        return _CosmoBolognaLib.IntVector_clear(self)

    def swap(self, v):
        return _CosmoBolognaLib.IntVector_swap(self, v)

    def get_allocator(self):
        return _CosmoBolognaLib.IntVector_get_allocator(self)

    def begin(self):
        return _CosmoBolognaLib.IntVector_begin(self)

    def end(self):
        return _CosmoBolognaLib.IntVector_end(self)

    def rbegin(self):
        return _CosmoBolognaLib.IntVector_rbegin(self)

    def rend(self):
        return _CosmoBolognaLib.IntVector_rend(self)

    def pop_back(self):
        return _CosmoBolognaLib.IntVector_pop_back(self)

    def erase(self, *args):
        return _CosmoBolognaLib.IntVector_erase(self, *args)

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_IntVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _CosmoBolognaLib.IntVector_push_back(self, x)

    def front(self):
        return _CosmoBolognaLib.IntVector_front(self)

    def back(self):
        return _CosmoBolognaLib.IntVector_back(self)

    def assign(self, n, x):
        return _CosmoBolognaLib.IntVector_assign(self, n, x)

    def resize(self, *args):
        return _CosmoBolognaLib.IntVector_resize(self, *args)

    def insert(self, *args):
        return _CosmoBolognaLib.IntVector_insert(self, *args)

    def reserve(self, n):
        return _CosmoBolognaLib.IntVector_reserve(self, n)

    def capacity(self):
        return _CosmoBolognaLib.IntVector_capacity(self)
    __swig_destroy__ = _CosmoBolognaLib.delete_IntVector
    __del__ = lambda self: None
IntVector_swigregister = _CosmoBolognaLib.IntVector_swigregister
IntVector_swigregister(IntVector)
cvar = _CosmoBolognaLib.cvar
yotta = cvar.yotta
zetta = cvar.zetta
exa = cvar.exa
peta = cvar.peta
tera = cvar.tera
giga = cvar.giga
mega = cvar.mega
kilo = cvar.kilo
ecto = cvar.ecto
deca = cvar.deca
deci = cvar.deci
centi = cvar.centi
milli = cvar.milli
micro = cvar.micro
nano = cvar.nano
pico = cvar.pico
femto = cvar.femto
atto = cvar.atto
zepto = cvar.zepto
yocto = cvar.yocto
fINT = cvar.fINT
fLONG = cvar.fLONG
fDP0 = cvar.fDP0
fDP1 = cvar.fDP1
fDP2 = cvar.fDP2
fDP3 = cvar.fDP3
fDP4 = cvar.fDP4
fDP5 = cvar.fDP5
fDP6 = cvar.fDP6
ee3 = cvar.ee3
pi = cvar.pi
ee = cvar.ee
hbar = cvar.hbar
cc = cvar.cc
kB = cvar.kB
sSB = cvar.sSB
el = cvar.el
alpha = cvar.alpha
epsilon0 = cvar.epsilon0
mu0 = cvar.mu0
NAv = cvar.NAv
GN = cvar.GN
gn = cvar.gn
lP = cvar.lP
MP = cvar.MP
Msol = cvar.Msol
me = cvar.me
mn = cvar.mn
mp = cvar.mp
au = cvar.au
pc = cvar.pc
TCMB = cvar.TCMB
yr = cvar.yr
col_default = cvar.col_default
col_red = cvar.col_red
col_bred = cvar.col_bred
col_onred = cvar.col_onred
col_green = cvar.col_green
col_blue = cvar.col_blue
col_yellow = cvar.col_yellow
col_purple = cvar.col_purple

class DoubleVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CosmoBolognaLib.DoubleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CosmoBolognaLib.DoubleVector___nonzero__(self)

    def __bool__(self):
        return _CosmoBolognaLib.DoubleVector___bool__(self)

    def __len__(self):
        return _CosmoBolognaLib.DoubleVector___len__(self)

    def pop(self):
        return _CosmoBolognaLib.DoubleVector_pop(self)

    def __getslice__(self, i, j):
        return _CosmoBolognaLib.DoubleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _CosmoBolognaLib.DoubleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _CosmoBolognaLib.DoubleVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _CosmoBolognaLib.DoubleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _CosmoBolognaLib.DoubleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _CosmoBolognaLib.DoubleVector___setitem__(self, *args)

    def append(self, x):
        return _CosmoBolognaLib.DoubleVector_append(self, x)

    def empty(self):
        return _CosmoBolognaLib.DoubleVector_empty(self)

    def size(self):
        return _CosmoBolognaLib.DoubleVector_size(self)

    def clear(self):
        return _CosmoBolognaLib.DoubleVector_clear(self)

    def swap(self, v):
        return _CosmoBolognaLib.DoubleVector_swap(self, v)

    def get_allocator(self):
        return _CosmoBolognaLib.DoubleVector_get_allocator(self)

    def begin(self):
        return _CosmoBolognaLib.DoubleVector_begin(self)

    def end(self):
        return _CosmoBolognaLib.DoubleVector_end(self)

    def rbegin(self):
        return _CosmoBolognaLib.DoubleVector_rbegin(self)

    def rend(self):
        return _CosmoBolognaLib.DoubleVector_rend(self)

    def pop_back(self):
        return _CosmoBolognaLib.DoubleVector_pop_back(self)

    def erase(self, *args):
        return _CosmoBolognaLib.DoubleVector_erase(self, *args)

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_DoubleVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _CosmoBolognaLib.DoubleVector_push_back(self, x)

    def front(self):
        return _CosmoBolognaLib.DoubleVector_front(self)

    def back(self):
        return _CosmoBolognaLib.DoubleVector_back(self)

    def assign(self, n, x):
        return _CosmoBolognaLib.DoubleVector_assign(self, n, x)

    def resize(self, *args):
        return _CosmoBolognaLib.DoubleVector_resize(self, *args)

    def insert(self, *args):
        return _CosmoBolognaLib.DoubleVector_insert(self, *args)

    def reserve(self, n):
        return _CosmoBolognaLib.DoubleVector_reserve(self, n)

    def capacity(self):
        return _CosmoBolognaLib.DoubleVector_capacity(self)
    __swig_destroy__ = _CosmoBolognaLib.delete_DoubleVector
    __del__ = lambda self: None
DoubleVector_swigregister = _CosmoBolognaLib.DoubleVector_swigregister
DoubleVector_swigregister(DoubleVector)

class StringVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CosmoBolognaLib.StringVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CosmoBolognaLib.StringVector___nonzero__(self)

    def __bool__(self):
        return _CosmoBolognaLib.StringVector___bool__(self)

    def __len__(self):
        return _CosmoBolognaLib.StringVector___len__(self)

    def pop(self):
        return _CosmoBolognaLib.StringVector_pop(self)

    def __getslice__(self, i, j):
        return _CosmoBolognaLib.StringVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _CosmoBolognaLib.StringVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _CosmoBolognaLib.StringVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _CosmoBolognaLib.StringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _CosmoBolognaLib.StringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _CosmoBolognaLib.StringVector___setitem__(self, *args)

    def append(self, x):
        return _CosmoBolognaLib.StringVector_append(self, x)

    def empty(self):
        return _CosmoBolognaLib.StringVector_empty(self)

    def size(self):
        return _CosmoBolognaLib.StringVector_size(self)

    def clear(self):
        return _CosmoBolognaLib.StringVector_clear(self)

    def swap(self, v):
        return _CosmoBolognaLib.StringVector_swap(self, v)

    def get_allocator(self):
        return _CosmoBolognaLib.StringVector_get_allocator(self)

    def begin(self):
        return _CosmoBolognaLib.StringVector_begin(self)

    def end(self):
        return _CosmoBolognaLib.StringVector_end(self)

    def rbegin(self):
        return _CosmoBolognaLib.StringVector_rbegin(self)

    def rend(self):
        return _CosmoBolognaLib.StringVector_rend(self)

    def pop_back(self):
        return _CosmoBolognaLib.StringVector_pop_back(self)

    def erase(self, *args):
        return _CosmoBolognaLib.StringVector_erase(self, *args)

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_StringVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _CosmoBolognaLib.StringVector_push_back(self, x)

    def front(self):
        return _CosmoBolognaLib.StringVector_front(self)

    def back(self):
        return _CosmoBolognaLib.StringVector_back(self)

    def assign(self, n, x):
        return _CosmoBolognaLib.StringVector_assign(self, n, x)

    def resize(self, *args):
        return _CosmoBolognaLib.StringVector_resize(self, *args)

    def insert(self, *args):
        return _CosmoBolognaLib.StringVector_insert(self, *args)

    def reserve(self, n):
        return _CosmoBolognaLib.StringVector_reserve(self, n)

    def capacity(self):
        return _CosmoBolognaLib.StringVector_capacity(self)
    __swig_destroy__ = _CosmoBolognaLib.delete_StringVector
    __del__ = lambda self: None
StringVector_swigregister = _CosmoBolognaLib.StringVector_swigregister
StringVector_swigregister(StringVector)

class DoubleVectorVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVectorVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleVectorVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CosmoBolognaLib.DoubleVectorVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CosmoBolognaLib.DoubleVectorVector___nonzero__(self)

    def __bool__(self):
        return _CosmoBolognaLib.DoubleVectorVector___bool__(self)

    def __len__(self):
        return _CosmoBolognaLib.DoubleVectorVector___len__(self)

    def pop(self):
        return _CosmoBolognaLib.DoubleVectorVector_pop(self)

    def __getslice__(self, i, j):
        return _CosmoBolognaLib.DoubleVectorVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _CosmoBolognaLib.DoubleVectorVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _CosmoBolognaLib.DoubleVectorVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _CosmoBolognaLib.DoubleVectorVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _CosmoBolognaLib.DoubleVectorVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _CosmoBolognaLib.DoubleVectorVector___setitem__(self, *args)

    def append(self, x):
        return _CosmoBolognaLib.DoubleVectorVector_append(self, x)

    def empty(self):
        return _CosmoBolognaLib.DoubleVectorVector_empty(self)

    def size(self):
        return _CosmoBolognaLib.DoubleVectorVector_size(self)

    def clear(self):
        return _CosmoBolognaLib.DoubleVectorVector_clear(self)

    def swap(self, v):
        return _CosmoBolognaLib.DoubleVectorVector_swap(self, v)

    def get_allocator(self):
        return _CosmoBolognaLib.DoubleVectorVector_get_allocator(self)

    def begin(self):
        return _CosmoBolognaLib.DoubleVectorVector_begin(self)

    def end(self):
        return _CosmoBolognaLib.DoubleVectorVector_end(self)

    def rbegin(self):
        return _CosmoBolognaLib.DoubleVectorVector_rbegin(self)

    def rend(self):
        return _CosmoBolognaLib.DoubleVectorVector_rend(self)

    def pop_back(self):
        return _CosmoBolognaLib.DoubleVectorVector_pop_back(self)

    def erase(self, *args):
        return _CosmoBolognaLib.DoubleVectorVector_erase(self, *args)

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_DoubleVectorVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _CosmoBolognaLib.DoubleVectorVector_push_back(self, x)

    def front(self):
        return _CosmoBolognaLib.DoubleVectorVector_front(self)

    def back(self):
        return _CosmoBolognaLib.DoubleVectorVector_back(self)

    def assign(self, n, x):
        return _CosmoBolognaLib.DoubleVectorVector_assign(self, n, x)

    def resize(self, *args):
        return _CosmoBolognaLib.DoubleVectorVector_resize(self, *args)

    def insert(self, *args):
        return _CosmoBolognaLib.DoubleVectorVector_insert(self, *args)

    def reserve(self, n):
        return _CosmoBolognaLib.DoubleVectorVector_reserve(self, n)

    def capacity(self):
        return _CosmoBolognaLib.DoubleVectorVector_capacity(self)
    __swig_destroy__ = _CosmoBolognaLib.delete_DoubleVectorVector
    __del__ = lambda self: None
DoubleVectorVector_swigregister = _CosmoBolognaLib.DoubleVectorVector_swigregister
DoubleVectorVector_swigregister(DoubleVectorVector)

class EnumTypes(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EnumTypes, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EnumTypes, name)
    __repr__ = _swig_repr
    _error_ = _CosmoBolognaLib.EnumTypes__error_
    _IO_ = _CosmoBolognaLib.EnumTypes__IO_
    _workInProgress_ = _CosmoBolognaLib.EnumTypes__workInProgress_
    _Omega_matter_LCDM_ = _CosmoBolognaLib.EnumTypes__Omega_matter_LCDM_
    _Omega_matter_ = _CosmoBolognaLib.EnumTypes__Omega_matter_
    _Omega_baryon_ = _CosmoBolognaLib.EnumTypes__Omega_baryon_
    _Omega_baryon_h2_ = _CosmoBolognaLib.EnumTypes__Omega_baryon_h2_
    _Omega_neutrinos_ = _CosmoBolognaLib.EnumTypes__Omega_neutrinos_
    _massless_neutrinos_ = _CosmoBolognaLib.EnumTypes__massless_neutrinos_
    _massive_neutrinos_ = _CosmoBolognaLib.EnumTypes__massive_neutrinos_
    _Omega_DE_ = _CosmoBolognaLib.EnumTypes__Omega_DE_
    _Omega_radiation_ = _CosmoBolognaLib.EnumTypes__Omega_radiation_
    _H0_ = _CosmoBolognaLib.EnumTypes__H0_
    _hh_ = _CosmoBolognaLib.EnumTypes__hh_
    _scalar_amp_ = _CosmoBolognaLib.EnumTypes__scalar_amp_
    _n_spec_ = _CosmoBolognaLib.EnumTypes__n_spec_
    _w0_ = _CosmoBolognaLib.EnumTypes__w0_
    _wa_ = _CosmoBolognaLib.EnumTypes__wa_
    _fNL_ = _CosmoBolognaLib.EnumTypes__fNL_
    _sigma8_ = _CosmoBolognaLib.EnumTypes__sigma8_
    _radians_ = _CosmoBolognaLib.EnumTypes__radians_
    _degrees_ = _CosmoBolognaLib.EnumTypes__degrees_
    _arcseconds_ = _CosmoBolognaLib.EnumTypes__arcseconds_
    _arcminutes_ = _CosmoBolognaLib.EnumTypes__arcminutes_
    _1D_ = _CosmoBolognaLib.EnumTypes__1D_
    _2D_ = _CosmoBolognaLib.EnumTypes__2D_
    _linear_ = _CosmoBolognaLib.EnumTypes__linear_
    _logarithmic_ = _CosmoBolognaLib.EnumTypes__logarithmic_
    _comovingCoordinates_ = _CosmoBolognaLib.EnumTypes__comovingCoordinates_
    _observedCoordinates_ = _CosmoBolognaLib.EnumTypes__observedCoordinates_
    _1D_data_ = _CosmoBolognaLib.EnumTypes__1D_data_
    _2D_data_ = _CosmoBolognaLib.EnumTypes__2D_data_
    _1D_collection_data_ = _CosmoBolognaLib.EnumTypes__1D_collection_data_
    _UniformPrior_ = _CosmoBolognaLib.EnumTypes__UniformPrior_
    _GaussianPrior_ = _CosmoBolognaLib.EnumTypes__GaussianPrior_
    _PoissonPrior_ = _CosmoBolognaLib.EnumTypes__PoissonPrior_
    _InterpolatedPrior_ = _CosmoBolognaLib.EnumTypes__InterpolatedPrior_
    _DiscretePrior_ = _CosmoBolognaLib.EnumTypes__DiscretePrior_
    _Likelihood_NotSet_ = _CosmoBolognaLib.EnumTypes__Likelihood_NotSet_
    _GaussianLikelihood_Model_ = _CosmoBolognaLib.EnumTypes__GaussianLikelihood_Model_
    _GaussianLikelihood_Error_ = _CosmoBolognaLib.EnumTypes__GaussianLikelihood_Error_
    _GaussianLikelihood_Covariance_ = _CosmoBolognaLib.EnumTypes__GaussianLikelihood_Covariance_
    _UserDefinedLikelihood_ = _CosmoBolognaLib.EnumTypes__UserDefinedLikelihood_
    _angular_lin_ = _CosmoBolognaLib.EnumTypes__angular_lin_
    _angular_log_ = _CosmoBolognaLib.EnumTypes__angular_log_
    _comoving_lin_ = _CosmoBolognaLib.EnumTypes__comoving_lin_
    _comoving_log_ = _CosmoBolognaLib.EnumTypes__comoving_log_
    _comovingCartesian_linlin_ = _CosmoBolognaLib.EnumTypes__comovingCartesian_linlin_
    _comovingCartesian_linlog_ = _CosmoBolognaLib.EnumTypes__comovingCartesian_linlog_
    _comovingCartesian_loglin_ = _CosmoBolognaLib.EnumTypes__comovingCartesian_loglin_
    _comovingCartesian_loglog_ = _CosmoBolognaLib.EnumTypes__comovingCartesian_loglog_
    _comovingPolar_linlin_ = _CosmoBolognaLib.EnumTypes__comovingPolar_linlin_
    _comovingPolar_linlog_ = _CosmoBolognaLib.EnumTypes__comovingPolar_linlog_
    _comovingPolar_loglin_ = _CosmoBolognaLib.EnumTypes__comovingPolar_loglin_
    _comovingPolar_loglog_ = _CosmoBolognaLib.EnumTypes__comovingPolar_loglog_
    _1D_monopole_ = _CosmoBolognaLib.EnumTypes__1D_monopole_
    _1D_projected_ = _CosmoBolognaLib.EnumTypes__1D_projected_
    _1D_deprojected_ = _CosmoBolognaLib.EnumTypes__1D_deprojected_
    _1D_multipoles_ = _CosmoBolognaLib.EnumTypes__1D_multipoles_
    _1D_wedges_ = _CosmoBolognaLib.EnumTypes__1D_wedges_
    _1D_filtered_ = _CosmoBolognaLib.EnumTypes__1D_filtered_
    _1D_angular_ = _CosmoBolognaLib.EnumTypes__1D_angular_
    _2D_Cartesian_ = _CosmoBolognaLib.EnumTypes__2D_Cartesian_
    _2D_polar_ = _CosmoBolognaLib.EnumTypes__2D_polar_
    _natural_ = _CosmoBolognaLib.EnumTypes__natural_
    _LandySzalay_ = _CosmoBolognaLib.EnumTypes__LandySzalay_
    _Poisson_ = _CosmoBolognaLib.EnumTypes__Poisson_
    _Jackknife_ = _CosmoBolognaLib.EnumTypes__Jackknife_
    _Bootstrap_ = _CosmoBolognaLib.EnumTypes__Bootstrap_
    _comoving_theta_ = _CosmoBolognaLib.EnumTypes__comoving_theta_
    _comoving_side_ = _CosmoBolognaLib.EnumTypes__comoving_side_
    _angular_connected_ = _CosmoBolognaLib.EnumTypes__angular_connected_
    _angular_reduced_ = _CosmoBolognaLib.EnumTypes__angular_reduced_
    _comoving_connected_ = _CosmoBolognaLib.EnumTypes__comoving_connected_
    _comoving_reduced_ = _CosmoBolognaLib.EnumTypes__comoving_reduced_
    _GenericObject_ = _CosmoBolognaLib.EnumTypes__GenericObject_
    _RandomObject_ = _CosmoBolognaLib.EnumTypes__RandomObject_
    _Mock_ = _CosmoBolognaLib.EnumTypes__Mock_
    _Halo_ = _CosmoBolognaLib.EnumTypes__Halo_
    _Galaxy_ = _CosmoBolognaLib.EnumTypes__Galaxy_
    _Cluster_ = _CosmoBolognaLib.EnumTypes__Cluster_
    _Void_ = _CosmoBolognaLib.EnumTypes__Void_
    _X_ = _CosmoBolognaLib.EnumTypes__X_
    _Y_ = _CosmoBolognaLib.EnumTypes__Y_
    _Z_ = _CosmoBolognaLib.EnumTypes__Z_
    _RA_ = _CosmoBolognaLib.EnumTypes__RA_
    _Dec_ = _CosmoBolognaLib.EnumTypes__Dec_
    _Redshift_ = _CosmoBolognaLib.EnumTypes__Redshift_
    _Dc_ = _CosmoBolognaLib.EnumTypes__Dc_
    _Weight_ = _CosmoBolognaLib.EnumTypes__Weight_
    _Mass_ = _CosmoBolognaLib.EnumTypes__Mass_
    _Richness_ = _CosmoBolognaLib.EnumTypes__Richness_
    _Magnitude_ = _CosmoBolognaLib.EnumTypes__Magnitude_
    _Vx_ = _CosmoBolognaLib.EnumTypes__Vx_
    Vy = _CosmoBolognaLib.EnumTypes_Vy
    Vz = _CosmoBolognaLib.EnumTypes_Vz
    _Region_ = _CosmoBolognaLib.EnumTypes__Region_
    _Radius_ = _CosmoBolognaLib.EnumTypes__Radius_
    _Generic_ = _CosmoBolognaLib.EnumTypes__Generic_
    _createRandom_box_ = _CosmoBolognaLib.EnumTypes__createRandom_box_
    _createRandom_square_ = _CosmoBolognaLib.EnumTypes__createRandom_square_
    _createRandom_shuffle_ = _CosmoBolognaLib.EnumTypes__createRandom_shuffle_
    _createRandom_cone_ = _CosmoBolognaLib.EnumTypes__createRandom_cone_
    _createRandom_MANGLE_ = _CosmoBolognaLib.EnumTypes__createRandom_MANGLE_
    _createRandom_VIPERS_ = _CosmoBolognaLib.EnumTypes__createRandom_VIPERS_

    def __init__(self):
        this = _CosmoBolognaLib.new_EnumTypes()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_EnumTypes
    __del__ = lambda self: None
EnumTypes_swigregister = _CosmoBolognaLib.EnumTypes_swigregister
EnumTypes_swigregister(EnumTypes)

class Chain(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Chain, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Chain, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Chain(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Chain
    __del__ = lambda self: None

    def Statistics(self, max=-1, min=-1):
        return _CosmoBolognaLib.Chain_Statistics(self, max, min)

    def ComputeDistribution(self, nbin):
        return _CosmoBolognaLib.Chain_ComputeDistribution(self, nbin)

    def var(self):
        return _CosmoBolognaLib.Chain_var(self)

    def dist(self):
        return _CosmoBolognaLib.Chain_dist(self)

    def mean(self):
        return _CosmoBolognaLib.Chain_mean(self)

    def median(self):
        return _CosmoBolognaLib.Chain_median(self)

    def std(self):
        return _CosmoBolognaLib.Chain_std(self)

    def set_chain_size(self, chain_size):
        return _CosmoBolognaLib.Chain_set_chain_size(self, chain_size)

    def set_chain_value(self, i, value):
        return _CosmoBolognaLib.Chain_set_chain_value(self, i, value)

    def chain_size(self):
        return _CosmoBolognaLib.Chain_chain_size(self)

    def chain_value(self, i):
        return _CosmoBolognaLib.Chain_chain_value(self, i)
Chain_swigregister = _CosmoBolognaLib.Chain_swigregister
Chain_swigregister(Chain)


_CosmoBolognaLib._UniformPrior__swigconstant(_CosmoBolognaLib)
_UniformPrior_ = _CosmoBolognaLib._UniformPrior_

_CosmoBolognaLib._GaussianPrior__swigconstant(_CosmoBolognaLib)
_GaussianPrior_ = _CosmoBolognaLib._GaussianPrior_

_CosmoBolognaLib._PoissonPrior__swigconstant(_CosmoBolognaLib)
_PoissonPrior_ = _CosmoBolognaLib._PoissonPrior_

_CosmoBolognaLib._InterpolatedPrior__swigconstant(_CosmoBolognaLib)
_InterpolatedPrior_ = _CosmoBolognaLib._InterpolatedPrior_

_CosmoBolognaLib._DiscretePrior__swigconstant(_CosmoBolognaLib)
_DiscretePrior_ = _CosmoBolognaLib._DiscretePrior_
class Prior(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Prior, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Prior, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Prior(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Prior
    __del__ = lambda self: None

    def __call__(self, xx):
        return _CosmoBolognaLib.Prior___call__(self, xx)

    def set_seed(self, seed):
        return _CosmoBolognaLib.Prior_set_seed(self, seed)

    def set_limits(self, xmin, xmax):
        return _CosmoBolognaLib.Prior_set_limits(self, xmin, xmax)

    def set_uniform_prior(self, xmin, xmax, seed=1):
        return _CosmoBolognaLib.Prior_set_uniform_prior(self, xmin, xmax, seed)

    def set_gaussian_prior(self, mean, sigma, seed=1):
        return _CosmoBolognaLib.Prior_set_gaussian_prior(self, mean, sigma, seed)

    def set_poisson_prior(self, mean, seed=1):
        return _CosmoBolognaLib.Prior_set_poisson_prior(self, mean, seed)

    def set_discrete_values(self, discrete_values, weights, seed=1):
        return _CosmoBolognaLib.Prior_set_discrete_values(self, discrete_values, weights, seed)

    def xmin(self):
        return _CosmoBolognaLib.Prior_xmin(self)

    def xmax(self):
        return _CosmoBolognaLib.Prior_xmax(self)

    def isIncluded(self, value):
        return _CosmoBolognaLib.Prior_isIncluded(self, value)

    def sample(self, *args):
        return _CosmoBolognaLib.Prior_sample(self, *args)

    def sample_vector(self, nvalues):
        return _CosmoBolognaLib.Prior_sample_vector(self, nvalues)
Prior_swigregister = _CosmoBolognaLib.Prior_swigregister
Prior_swigregister(Prior)


_CosmoBolognaLib._fixed__swigconstant(_CosmoBolognaLib)
_fixed_ = _CosmoBolognaLib._fixed_

_CosmoBolognaLib._free__swigconstant(_CosmoBolognaLib)
_free_ = _CosmoBolognaLib._free_
class Parameter(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Parameter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Parameter, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Parameter(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Parameter
    __del__ = lambda self: None

    def value(self):
        return _CosmoBolognaLib.Parameter_value(self)

    def best_value(self):
        return _CosmoBolognaLib.Parameter_best_value(self)

    def name(self):
        return _CosmoBolognaLib.Parameter_name(self)

    def chain(self, i):
        return _CosmoBolognaLib.Parameter_chain(self, i)

    def chains(self):
        return _CosmoBolognaLib.Parameter_chains(self)

    def mean(self):
        return _CosmoBolognaLib.Parameter_mean(self)

    def median(self):
        return _CosmoBolognaLib.Parameter_median(self)

    def std(self):
        return _CosmoBolognaLib.Parameter_std(self)

    def prior(self):
        return _CosmoBolognaLib.Parameter_prior(self)

    def interval_size(self):
        return _CosmoBolognaLib.Parameter_interval_size(self)

    def PriorProbability(self, *args):
        return _CosmoBolognaLib.Parameter_PriorProbability(self, *args)

    def set_prior_seed(self, seed):
        return _CosmoBolognaLib.Parameter_set_prior_seed(self, seed)

    def set_value(self, value):
        return _CosmoBolognaLib.Parameter_set_value(self, value)

    def set_best_value(self, value):
        return _CosmoBolognaLib.Parameter_set_best_value(self, value)

    def set_name(self, name):
        return _CosmoBolognaLib.Parameter_set_name(self, name)

    def set_pType(self, pType):
        return _CosmoBolognaLib.Parameter_set_pType(self, pType)

    def set_prior(self, prior):
        return _CosmoBolognaLib.Parameter_set_prior(self, prior)

    def set_chains(self, nchains, chain_size):
        return _CosmoBolognaLib.Parameter_set_chains(self, nchains, chain_size)

    def set_chain_value(self, chain, position, value):
        return _CosmoBolognaLib.Parameter_set_chain_value(self, chain, position, value)

    def set_chains_values(self, position, values):
        return _CosmoBolognaLib.Parameter_set_chains_values(self, position, values)

    def set_chains_values_from_prior(self, position):
        return _CosmoBolognaLib.Parameter_set_chains_values_from_prior(self, position)

    def isFixed(self):
        return _CosmoBolognaLib.Parameter_isFixed(self)

    def sample_from_prior(self, *args):
        return _CosmoBolognaLib.Parameter_sample_from_prior(self, *args)

    def merge_chains(self, max=-1, min=-1, thin=1):
        return _CosmoBolognaLib.Parameter_merge_chains(self, max, min, thin)

    def chains_convergence(self, max=-1, min=-1, thin=1):
        return _CosmoBolognaLib.Parameter_chains_convergence(self, max, min, thin)

    def random_value(self):
        return _CosmoBolognaLib.Parameter_random_value(self)
Parameter_swigregister = _CosmoBolognaLib.Parameter_swigregister
Parameter_swigregister(Parameter)

class Model(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Model, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Model, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_Model
    __del__ = lambda self: None

    def __call__(self, *args):
        return _CosmoBolognaLib.Model___call__(self, *args)

    def npar(self):
        return _CosmoBolognaLib.Model_npar(self)

    def npar_eff(self):
        return _CosmoBolognaLib.Model_npar_eff(self)

    def dimension(self):
        return _CosmoBolognaLib.Model_dimension(self)

    def parameter(self, i):
        return _CosmoBolognaLib.Model_parameter(self, i)

    def parameters(self):
        return _CosmoBolognaLib.Model_parameters(self)

    def parameter_values(self):
        return _CosmoBolognaLib.Model_parameter_values(self)

    def parameter_values_from_chain(self, chain, position):
        return _CosmoBolognaLib.Model_parameter_values_from_chain(self, chain, position)

    def set_parameter_values(self, parameter_values):
        return _CosmoBolognaLib.Model_set_parameter_values(self, parameter_values)

    def set_chains(self, nchains, chain_size):
        return _CosmoBolognaLib.Model_set_chains(self, nchains, chain_size)

    def fixed_parameters(self):
        return _CosmoBolognaLib.Model_fixed_parameters(self)

    def write_model(self, *args):
        return _CosmoBolognaLib.Model_write_model(self, *args)
Model_swigregister = _CosmoBolognaLib.Model_swigregister
Model_swigregister(Model)

class Model1D(Model):
    __swig_setmethods__ = {}
    for _s in [Model]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Model1D, name, value)
    __swig_getmethods__ = {}
    for _s in [Model]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Model1D, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Model1D(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Model1D
    __del__ = lambda self: None

    def __call__(self, *args):
        return _CosmoBolognaLib.Model1D___call__(self, *args)

    def write_model(self, *args):
        return _CosmoBolognaLib.Model1D_write_model(self, *args)
Model1D_swigregister = _CosmoBolognaLib.Model1D_swigregister
Model1D_swigregister(Model1D)

class Model2D(Model):
    __swig_setmethods__ = {}
    for _s in [Model]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Model2D, name, value)
    __swig_getmethods__ = {}
    for _s in [Model]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Model2D, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Model2D(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Model2D
    __del__ = lambda self: None

    def __call__(self, *args):
        return _CosmoBolognaLib.Model2D___call__(self, *args)

    def write_model(self, *args):
        return _CosmoBolognaLib.Model2D_write_model(self, *args)
Model2D_swigregister = _CosmoBolognaLib.Model2D_swigregister
Model2D_swigregister(Model2D)

class STR_params(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, STR_params, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, STR_params, name)
    __repr__ = _swig_repr
    __swig_setmethods__["data"] = _CosmoBolognaLib.STR_params_data_set
    __swig_getmethods__["data"] = _CosmoBolognaLib.STR_params_data_get
    if _newclass:
        data = _swig_property(_CosmoBolognaLib.STR_params_data_get, _CosmoBolognaLib.STR_params_data_set)
    __swig_setmethods__["model"] = _CosmoBolognaLib.STR_params_model_set
    __swig_getmethods__["model"] = _CosmoBolognaLib.STR_params_model_get
    if _newclass:
        model = _swig_property(_CosmoBolognaLib.STR_params_model_get, _CosmoBolognaLib.STR_params_model_set)

    def __init__(self, _data, _model):
        this = _CosmoBolognaLib.new_STR_params(_data, _model)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_STR_params
    __del__ = lambda self: None
STR_params_swigregister = _CosmoBolognaLib.STR_params_swigregister
STR_params_swigregister(STR_params)


def chi2_1D_model_1par(model_parameter, fixed_parameters):
    return _CosmoBolognaLib.chi2_1D_model_1par(model_parameter, fixed_parameters)
chi2_1D_model_1par = _CosmoBolognaLib.chi2_1D_model_1par

def chi2_1D_error_1par(model_parameter, fixed_parameters):
    return _CosmoBolognaLib.chi2_1D_error_1par(model_parameter, fixed_parameters)
chi2_1D_error_1par = _CosmoBolognaLib.chi2_1D_error_1par

def chi2_1D_covariance_1par(model_parameter, fixed_parameters):
    return _CosmoBolognaLib.chi2_1D_covariance_1par(model_parameter, fixed_parameters)
chi2_1D_covariance_1par = _CosmoBolognaLib.chi2_1D_covariance_1par

def chi2_2D_error_1par(model_parameter, fixed_parameters):
    return _CosmoBolognaLib.chi2_2D_error_1par(model_parameter, fixed_parameters)
chi2_2D_error_1par = _CosmoBolognaLib.chi2_2D_error_1par

def chi2_1D_model_npar(model_parameters, fixed_parameters):
    return _CosmoBolognaLib.chi2_1D_model_npar(model_parameters, fixed_parameters)
chi2_1D_model_npar = _CosmoBolognaLib.chi2_1D_model_npar

def chi2_1D_error_npar(model_parameters, fixed_parameters):
    return _CosmoBolognaLib.chi2_1D_error_npar(model_parameters, fixed_parameters)
chi2_1D_error_npar = _CosmoBolognaLib.chi2_1D_error_npar

def chi2_1D_covariance_npar(model_parameters, fixed_parameters):
    return _CosmoBolognaLib.chi2_1D_covariance_npar(model_parameters, fixed_parameters)
chi2_1D_covariance_npar = _CosmoBolognaLib.chi2_1D_covariance_npar

def chi2_2D_error_npar(model_parameters, fixed_parameters):
    return _CosmoBolognaLib.chi2_2D_error_npar(model_parameters, fixed_parameters)
chi2_2D_error_npar = _CosmoBolognaLib.chi2_2D_error_npar
class Chi2(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Chi2, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Chi2, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Chi2(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Chi2
    __del__ = lambda self: None

    def minimize(self, *args):
        return _CosmoBolognaLib.Chi2_minimize(self, *args)
Chi2_swigregister = _CosmoBolognaLib.Chi2_swigregister
Chi2_swigregister(Chi2)


_CosmoBolognaLib._Likelihood_NotSet__swigconstant(_CosmoBolognaLib)
_Likelihood_NotSet_ = _CosmoBolognaLib._Likelihood_NotSet_

_CosmoBolognaLib._GaussianLikelihood_Model__swigconstant(_CosmoBolognaLib)
_GaussianLikelihood_Model_ = _CosmoBolognaLib._GaussianLikelihood_Model_

_CosmoBolognaLib._GaussianLikelihood_Error__swigconstant(_CosmoBolognaLib)
_GaussianLikelihood_Error_ = _CosmoBolognaLib._GaussianLikelihood_Error_

_CosmoBolognaLib._GaussianLikelihood_Covariance__swigconstant(_CosmoBolognaLib)
_GaussianLikelihood_Covariance_ = _CosmoBolognaLib._GaussianLikelihood_Covariance_

_CosmoBolognaLib._UserDefinedLikelihood__swigconstant(_CosmoBolognaLib)
_UserDefinedLikelihood_ = _CosmoBolognaLib._UserDefinedLikelihood_
class STR_likelihood_parameters(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, STR_likelihood_parameters, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, STR_likelihood_parameters, name)
    __repr__ = _swig_repr
    __swig_setmethods__["data"] = _CosmoBolognaLib.STR_likelihood_parameters_data_set
    __swig_getmethods__["data"] = _CosmoBolognaLib.STR_likelihood_parameters_data_get
    if _newclass:
        data = _swig_property(_CosmoBolognaLib.STR_likelihood_parameters_data_get, _CosmoBolognaLib.STR_likelihood_parameters_data_set)
    __swig_setmethods__["model"] = _CosmoBolognaLib.STR_likelihood_parameters_model_set
    __swig_getmethods__["model"] = _CosmoBolognaLib.STR_likelihood_parameters_model_get
    if _newclass:
        model = _swig_property(_CosmoBolognaLib.STR_likelihood_parameters_model_get, _CosmoBolognaLib.STR_likelihood_parameters_model_set)

    def __init__(self, _data, _model):
        this = _CosmoBolognaLib.new_STR_likelihood_parameters(_data, _model)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_STR_likelihood_parameters
    __del__ = lambda self: None
STR_likelihood_parameters_swigregister = _CosmoBolognaLib.STR_likelihood_parameters_swigregister
STR_likelihood_parameters_swigregister(STR_likelihood_parameters)


def LogLikelihood_Gaussian_1D_model(model_parameters, inputs):
    return _CosmoBolognaLib.LogLikelihood_Gaussian_1D_model(model_parameters, inputs)
LogLikelihood_Gaussian_1D_model = _CosmoBolognaLib.LogLikelihood_Gaussian_1D_model

def LogLikelihood_Gaussian_1D_error(model_parameters, inputs):
    return _CosmoBolognaLib.LogLikelihood_Gaussian_1D_error(model_parameters, inputs)
LogLikelihood_Gaussian_1D_error = _CosmoBolognaLib.LogLikelihood_Gaussian_1D_error

def LogLikelihood_Gaussian_1D_covariance(model_parameters, inputs):
    return _CosmoBolognaLib.LogLikelihood_Gaussian_1D_covariance(model_parameters, inputs)
LogLikelihood_Gaussian_1D_covariance = _CosmoBolognaLib.LogLikelihood_Gaussian_1D_covariance

def LogLikelihood_Gaussian_2D_model(model_parameters, inputs):
    return _CosmoBolognaLib.LogLikelihood_Gaussian_2D_model(model_parameters, inputs)
LogLikelihood_Gaussian_2D_model = _CosmoBolognaLib.LogLikelihood_Gaussian_2D_model

def LogLikelihood_Gaussian_2D_error(model_parameters, inputs):
    return _CosmoBolognaLib.LogLikelihood_Gaussian_2D_error(model_parameters, inputs)
LogLikelihood_Gaussian_2D_error = _CosmoBolognaLib.LogLikelihood_Gaussian_2D_error
class Likelihood(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Likelihood, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Likelihood, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Likelihood(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Likelihood
    __del__ = lambda self: None

    def best_fit(self, i):
        return _CosmoBolognaLib.Likelihood_best_fit(self, i)

    def __call__(self, pp):
        return _CosmoBolognaLib.Likelihood___call__(self, pp)

    def set_likelihood_type(self, likelihood_type, cov):
        return _CosmoBolognaLib.Likelihood_set_likelihood_type(self, likelihood_type, cov)

    def set_data(self, data):
        return _CosmoBolognaLib.Likelihood_set_data(self, data)

    def set_model(self, model):
        return _CosmoBolognaLib.Likelihood_set_model(self, model)

    def set_likelihood_function(self, *args):
        return _CosmoBolognaLib.Likelihood_set_likelihood_function(self, *args)

    def LogPriorProbability(self, *args):
        return _CosmoBolognaLib.Likelihood_LogPriorProbability(self, *args)

    def minimize_LogLikelihood(self, usePriors=True, max_iter=100, tol=1.e-6):
        return _CosmoBolognaLib.Likelihood_minimize_LogLikelihood(self, usePriors, max_iter, tol)

    def sample_stretch_move(self, *args):
        return _CosmoBolognaLib.Likelihood_sample_stretch_move(self, *args)

    def sample_tabulated_likelihood(self, *args):
        return _CosmoBolognaLib.Likelihood_sample_tabulated_likelihood(self, *args)

    def write_chain(self, output_dir, output_file, start=0.5, stop=1, thin=1):
        return _CosmoBolognaLib.Likelihood_write_chain(self, output_dir, output_file, start, stop, thin)
Likelihood_swigregister = _CosmoBolognaLib.Likelihood_swigregister
Likelihood_swigregister(Likelihood)


_CosmoBolognaLib._Omega_matter_LCDM__swigconstant(_CosmoBolognaLib)
_Omega_matter_LCDM_ = _CosmoBolognaLib._Omega_matter_LCDM_

_CosmoBolognaLib._Omega_matter__swigconstant(_CosmoBolognaLib)
_Omega_matter_ = _CosmoBolognaLib._Omega_matter_

_CosmoBolognaLib._Omega_baryon__swigconstant(_CosmoBolognaLib)
_Omega_baryon_ = _CosmoBolognaLib._Omega_baryon_

_CosmoBolognaLib._Omega_baryon_h2__swigconstant(_CosmoBolognaLib)
_Omega_baryon_h2_ = _CosmoBolognaLib._Omega_baryon_h2_

_CosmoBolognaLib._Omega_neutrinos__swigconstant(_CosmoBolognaLib)
_Omega_neutrinos_ = _CosmoBolognaLib._Omega_neutrinos_

_CosmoBolognaLib._massless_neutrinos__swigconstant(_CosmoBolognaLib)
_massless_neutrinos_ = _CosmoBolognaLib._massless_neutrinos_

_CosmoBolognaLib._massive_neutrinos__swigconstant(_CosmoBolognaLib)
_massive_neutrinos_ = _CosmoBolognaLib._massive_neutrinos_

_CosmoBolognaLib._Omega_DE__swigconstant(_CosmoBolognaLib)
_Omega_DE_ = _CosmoBolognaLib._Omega_DE_

_CosmoBolognaLib._Omega_radiation__swigconstant(_CosmoBolognaLib)
_Omega_radiation_ = _CosmoBolognaLib._Omega_radiation_

_CosmoBolognaLib._H0__swigconstant(_CosmoBolognaLib)
_H0_ = _CosmoBolognaLib._H0_

_CosmoBolognaLib._hh__swigconstant(_CosmoBolognaLib)
_hh_ = _CosmoBolognaLib._hh_

_CosmoBolognaLib._scalar_amp__swigconstant(_CosmoBolognaLib)
_scalar_amp_ = _CosmoBolognaLib._scalar_amp_

_CosmoBolognaLib._n_spec__swigconstant(_CosmoBolognaLib)
_n_spec_ = _CosmoBolognaLib._n_spec_

_CosmoBolognaLib._w0__swigconstant(_CosmoBolognaLib)
_w0_ = _CosmoBolognaLib._w0_

_CosmoBolognaLib._wa__swigconstant(_CosmoBolognaLib)
_wa_ = _CosmoBolognaLib._wa_

_CosmoBolognaLib._fNL__swigconstant(_CosmoBolognaLib)
_fNL_ = _CosmoBolognaLib._fNL_

_CosmoBolognaLib._sigma8__swigconstant(_CosmoBolognaLib)
_sigma8_ = _CosmoBolognaLib._sigma8_
class Cosmology(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Cosmology, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Cosmology, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Cosmology(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Cosmology
    __del__ = lambda self: None

    def value(self, parameter):
        return _CosmoBolognaLib.Cosmology_value(self, parameter)

    def Omega_matter(self):
        return _CosmoBolognaLib.Cosmology_Omega_matter(self)

    def Omega_baryon(self):
        return _CosmoBolognaLib.Cosmology_Omega_baryon(self)

    def Omega_neutrinos(self):
        return _CosmoBolognaLib.Cosmology_Omega_neutrinos(self)

    def massless_neutrinos(self):
        return _CosmoBolognaLib.Cosmology_massless_neutrinos(self)

    def massive_neutrinos(self):
        return _CosmoBolognaLib.Cosmology_massive_neutrinos(self)

    def Omega_DE(self):
        return _CosmoBolognaLib.Cosmology_Omega_DE(self)

    def Omega_radiation(self):
        return _CosmoBolognaLib.Cosmology_Omega_radiation(self)

    def Omega_k(self):
        return _CosmoBolognaLib.Cosmology_Omega_k(self)

    def Omega_CDM(self):
        return _CosmoBolognaLib.Cosmology_Omega_CDM(self)

    def H0(self):
        return _CosmoBolognaLib.Cosmology_H0(self)

    def hh(self):
        return _CosmoBolognaLib.Cosmology_hh(self)

    def t_H(self):
        return _CosmoBolognaLib.Cosmology_t_H(self)

    def D_H(self):
        return _CosmoBolognaLib.Cosmology_D_H(self)

    def scalar_amp(self):
        return _CosmoBolognaLib.Cosmology_scalar_amp(self)

    def n_spec(self):
        return _CosmoBolognaLib.Cosmology_n_spec(self)

    def w0(self):
        return _CosmoBolognaLib.Cosmology_w0(self)

    def wa(self):
        return _CosmoBolognaLib.Cosmology_wa(self)

    def RhoZero(self):
        return _CosmoBolognaLib.Cosmology_RhoZero(self)

    def fNL(self):
        return _CosmoBolognaLib.Cosmology_fNL(self)

    def type_NG(self):
        return _CosmoBolognaLib.Cosmology_type_NG(self)

    def Pk0_EH(self):
        return _CosmoBolognaLib.Cosmology_Pk0_EH(self)

    def Pk0_CAMB(self):
        return _CosmoBolognaLib.Cosmology_Pk0_CAMB(self)

    def Pk0_MPTbreeze(self):
        return _CosmoBolognaLib.Cosmology_Pk0_MPTbreeze(self)

    def Pk0_CLASS(self):
        return _CosmoBolognaLib.Cosmology_Pk0_CLASS(self)

    def model(self):
        return _CosmoBolognaLib.Cosmology_model(self)

    def unit(self):
        return _CosmoBolognaLib.Cosmology_unit(self)

    def print_parameters(self):
        return _CosmoBolognaLib.Cosmology_print_parameters(self)

    def set_parameter(self, *args):
        return _CosmoBolognaLib.Cosmology_set_parameter(self, *args)

    def set_Omega(self, Omega_matter=0.27):
        return _CosmoBolognaLib.Cosmology_set_Omega(self, Omega_matter)

    def set_OmegaB(self, Omega_baryon=0.046):
        return _CosmoBolognaLib.Cosmology_set_OmegaB(self, Omega_baryon)

    def set_OmegaB_h2(self, Omega_baryonh2=0.0222):
        return _CosmoBolognaLib.Cosmology_set_OmegaB_h2(self, Omega_baryonh2)

    def set_OmegaM(self, Omega_matter=0.27):
        return _CosmoBolognaLib.Cosmology_set_OmegaM(self, Omega_matter)

    def set_OmegaDE(self, Omega_DE=0.73):
        return _CosmoBolognaLib.Cosmology_set_OmegaDE(self, Omega_DE)

    def set_OmegaNu(self, Omega_neutrinos=0., massless_neutrinos=3.04, massive_neutrinos=0):
        return _CosmoBolognaLib.Cosmology_set_OmegaNu(self, Omega_neutrinos, massless_neutrinos, massive_neutrinos)

    def set_Omega_radiation(self, Omega_radiation):
        return _CosmoBolognaLib.Cosmology_set_Omega_radiation(self, Omega_radiation)

    def set_hh(self, hh=0.7):
        return _CosmoBolognaLib.Cosmology_set_hh(self, hh)

    def set_H0(self, H0=70.):
        return _CosmoBolognaLib.Cosmology_set_H0(self, H0)

    def set_sigma8(self, sigma8=-1.):
        return _CosmoBolognaLib.Cosmology_set_sigma8(self, sigma8)

    def set_scalar_amp(self, scalar_amp=2.46e-9):
        return _CosmoBolognaLib.Cosmology_set_scalar_amp(self, scalar_amp)

    def set_n_spec(self, n_spec):
        return _CosmoBolognaLib.Cosmology_set_n_spec(self, n_spec)

    def set_w0(self, w0=-1.):
        return _CosmoBolognaLib.Cosmology_set_w0(self, w0)

    def set_wa(self, wa=0.):
        return _CosmoBolognaLib.Cosmology_set_wa(self, wa)

    def set_RhoZero(self, RhoZero=7.5e10):
        return _CosmoBolognaLib.Cosmology_set_RhoZero(self, RhoZero)

    def set_fNL(self, fNL=0.):
        return _CosmoBolognaLib.Cosmology_set_fNL(self, fNL)

    def set_type_NG(self, type_NG=1):
        return _CosmoBolognaLib.Cosmology_set_type_NG(self, type_NG)

    def set_model(self, *args):
        return _CosmoBolognaLib.Cosmology_set_model(self, *args)

    def set_unit(self, unit=1):
        return _CosmoBolognaLib.Cosmology_set_unit(self, unit)

    def OmegaM(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_OmegaM(self, redshift)

    def OmegaDE(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_OmegaDE(self, redshift)

    def OmegaR(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_OmegaR(self, redshift)

    def OmegaK(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_OmegaK(self, redshift)

    def Omega(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_Omega(self, redshift)

    def Rho(self, Omega_matter=0.27, Omega_neutrinos=0., unit1=1):
        return _CosmoBolognaLib.Cosmology_Rho(self, Omega_matter, Omega_neutrinos, unit1)

    def DeltaR(self, Delta_crit=200., redshift=0.):
        return _CosmoBolognaLib.Cosmology_DeltaR(self, Delta_crit, redshift)

    def w_CPL(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_w_CPL(self, redshift)

    def f_DE(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_f_DE(self, redshift)

    def EE(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_EE(self, redshift)

    def EE_inv(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_EE_inv(self, redshift)

    def EE_inv2(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_EE_inv2(self, redshift)

    def EE_inv3(self, aa):
        return _CosmoBolognaLib.Cosmology_EE_inv3(self, aa)

    def HH(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_HH(self, redshift)

    def gg(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_gg(self, redshift)

    def DD(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_DD(self, redshift)

    def sigma8(self, *args):
        return _CosmoBolognaLib.Cosmology_sigma8(self, *args)

    def lookback_time(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_lookback_time(self, redshift)

    def cosmic_time(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_cosmic_time(self, redshift)

    def EE2(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_EE2(self, redshift)

    def qq(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_qq(self, redshift)

    def Hdot(self, redshift=0.):
        return _CosmoBolognaLib.Cosmology_Hdot(self, redshift)

    def z_decoupling(self):
        return _CosmoBolognaLib.Cosmology_z_decoupling(self)

    def z_drag(self):
        return _CosmoBolognaLib.Cosmology_z_drag(self)

    def z_acc(self):
        return _CosmoBolognaLib.Cosmology_z_acc(self)

    def z_eq(self):
        return _CosmoBolognaLib.Cosmology_z_eq(self)

    def sound_speed(self, redshift, T_CMB=2.7255):
        return _CosmoBolognaLib.Cosmology_sound_speed(self, redshift, T_CMB)

    def rs_integrand(self, redshift, T_CMB=2.7255):
        return _CosmoBolognaLib.Cosmology_rs_integrand(self, redshift, T_CMB)

    def Mag_Volume_limited(self, z_max=1., mag_lim=-20.):
        return _CosmoBolognaLib.Cosmology_Mag_Volume_limited(self, z_max, mag_lim)

    def Lum_bol(self, redshift=0., flux=1.):
        return _CosmoBolognaLib.Cosmology_Lum_bol(self, redshift, flux)

    def Redshift_LCDM(self, d_c=1., z1_guess=0., z2_guess=10., go_fast=1, prec=0.0001):
        return _CosmoBolognaLib.Cosmology_Redshift_LCDM(self, d_c, z1_guess, z2_guess, go_fast, prec)

    def Redshift(self, *args):
        return _CosmoBolognaLib.Cosmology_Redshift(self, *args)

    def Redshift_time(self, arg2, arg3, arg4):
        return _CosmoBolognaLib.Cosmology_Redshift_time(self, arg2, arg3, arg4)

    def deltac(self, arg2):
        return _CosmoBolognaLib.Cosmology_deltac(self, arg2)

    def Deltavir(self, redshift):
        return _CosmoBolognaLib.Cosmology_Deltavir(self, redshift)

    def D_C(self, arg2):
        return _CosmoBolognaLib.Cosmology_D_C(self, arg2)

    def D_C_LCDM(self, arg2):
        return _CosmoBolognaLib.Cosmology_D_C_LCDM(self, arg2)

    def D_C_table(self, arg2, arg3, arg4, arg5, arg6, arg7):
        return _CosmoBolognaLib.Cosmology_D_C_table(self, arg2, arg3, arg4, arg5, arg6, arg7)

    def D_M(self, arg2):
        return _CosmoBolognaLib.Cosmology_D_M(self, arg2)

    def D_A(self, arg2):
        return _CosmoBolognaLib.Cosmology_D_A(self, arg2)

    def D_L(self, arg2):
        return _CosmoBolognaLib.Cosmology_D_L(self, arg2)

    def D_V(self, arg2):
        return _CosmoBolognaLib.Cosmology_D_V(self, arg2)

    def F_AP(self, arg2):
        return _CosmoBolognaLib.Cosmology_F_AP(self, arg2)

    def Distance(self, arg2, arg3):
        return _CosmoBolognaLib.Cosmology_Distance(self, arg2, arg3)

    def Volume(self, *args):
        return _CosmoBolognaLib.Cosmology_Volume(self, *args)

    def max_redshift(self, arg2, arg3, arg4):
        return _CosmoBolognaLib.Cosmology_max_redshift(self, arg2, arg3, arg4)

    def dV_dZdOmega(self, arg2, arg3):
        return _CosmoBolognaLib.Cosmology_dV_dZdOmega(self, arg2, arg3)

    def mass_function_fast(self, *args):
        return _CosmoBolognaLib.Cosmology_mass_function_fast(self, *args)

    def mass_function(self, *args):
        return _CosmoBolognaLib.Cosmology_mass_function(self, *args)

    def n_haloes(self, *args):
        return _CosmoBolognaLib.Cosmology_n_haloes(self, *args)

    def MhaloMin(self, *args):
        return _CosmoBolognaLib.Cosmology_MhaloMin(self, *args)

    def pw(self, arg2, arg3, arg4):
        return _CosmoBolognaLib.Cosmology_pw(self, arg2, arg3, arg4)

    def pz(self, *args):
        return _CosmoBolognaLib.Cosmology_pz(self, *args)

    def cumPw(self, arg2, arg3, arg4):
        return _CosmoBolognaLib.Cosmology_cumPw(self, arg2, arg3, arg4)

    def medianwf(self, arg2, arg3, arg4):
        return _CosmoBolognaLib.Cosmology_medianwf(self, arg2, arg3, arg4)

    def medianzf(self, *args):
        return _CosmoBolognaLib.Cosmology_medianzf(self, *args)

    def wf(self, *args):
        return _CosmoBolognaLib.Cosmology_wf(self, *args)

    def unevolved_mass_function(self, mass_accr):
        return _CosmoBolognaLib.Cosmology_unevolved_mass_function(self, mass_accr)

    def concentration(self, Vmax, Rmax):
        return _CosmoBolognaLib.Cosmology_concentration(self, Vmax, Rmax)

    def As(self, sigma8):
        return _CosmoBolognaLib.Cosmology_As(self, sigma8)

    def sigma8_interpolated(self, redshift):
        return _CosmoBolognaLib.Cosmology_sigma8_interpolated(self, redshift)

    def Pk_UnNorm(self, arg2, arg3, arg4):
        return _CosmoBolognaLib.Cosmology_Pk_UnNorm(self, arg2, arg3, arg4)

    def Pk_output_file(self, *args):
        return _CosmoBolognaLib.Cosmology_Pk_output_file(self, *args)

    def run_CAMB(self, *args):
        return _CosmoBolognaLib.Cosmology_run_CAMB(self, *args)

    def Table_PkCodes(self, *args):
        return _CosmoBolognaLib.Cosmology_Table_PkCodes(self, *args)

    def Table_XiCodes(self, code, NL, rr, xi, redshift, output_root, k_max, file_par):
        return _CosmoBolognaLib.Cosmology_Table_XiCodes(self, code, NL, rr, xi, redshift, output_root, k_max, file_par)

    def Pk_0(self, *args):
        return _CosmoBolognaLib.Cosmology_Pk_0(self, *args)

    def Pk(self, *args):
        return _CosmoBolognaLib.Cosmology_Pk(self, *args)

    def Pk_Kaiser_multipoles(self, *args):
        return _CosmoBolognaLib.Cosmology_Pk_Kaiser_multipoles(self, *args)

    def Pk_DeWiggle(self, *args):
        return _CosmoBolognaLib.Cosmology_Pk_DeWiggle(self, *args)

    def SSR(self, *args):
        return _CosmoBolognaLib.Cosmology_SSR(self, *args)

    def SSR_norm(self, *args):
        return _CosmoBolognaLib.Cosmology_SSR_norm(self, *args)

    def SSM(self, *args):
        return _CosmoBolognaLib.Cosmology_SSM(self, *args)

    def SSM_norm(self, *args):
        return _CosmoBolognaLib.Cosmology_SSM_norm(self, *args)

    def dnSR(self, *args):
        return _CosmoBolognaLib.Cosmology_dnSR(self, *args)

    def dnSM(self, *args):
        return _CosmoBolognaLib.Cosmology_dnSM(self, *args)

    def xi_DM(self, *args):
        return _CosmoBolognaLib.Cosmology_xi_DM(self, *args)

    def xi_DM_DeWiggle(self, *args):
        return _CosmoBolognaLib.Cosmology_xi_DM_DeWiggle(self, *args)

    def get_xi(self, *args):
        return _CosmoBolognaLib.Cosmology_get_xi(self, *args)

    def get_barred_xi(self, *args):
        return _CosmoBolognaLib.Cosmology_get_barred_xi(self, *args)

    def wp_DM(self, *args):
        return _CosmoBolognaLib.Cosmology_wp_DM(self, *args)

    def k_star(self, *args):
        return _CosmoBolognaLib.Cosmology_k_star(self, *args)

    def sigmaR_DM(self, *args):
        return _CosmoBolognaLib.Cosmology_sigmaR_DM(self, *args)

    def sigma8_Pk(self, *args):
        return _CosmoBolognaLib.Cosmology_sigma8_Pk(self, *args)

    def bias_halo(self, *args):
        return _CosmoBolognaLib.Cosmology_bias_halo(self, *args)

    def bias_eff(self, *args):
        return _CosmoBolognaLib.Cosmology_bias_eff(self, *args)

    def linear_growth_rate(self, arg2, kk=-1.):
        return _CosmoBolognaLib.Cosmology_linear_growth_rate(self, arg2, kk)

    def fsigma8(self, *args):
        return _CosmoBolognaLib.Cosmology_fsigma8(self, *args)

    def beta(self, *args):
        return _CosmoBolognaLib.Cosmology_beta(self, *args)

    def error_beta(self, *args):
        return _CosmoBolognaLib.Cosmology_error_beta(self, *args)

    def error_beta_measured(self, *args):
        return _CosmoBolognaLib.Cosmology_error_beta_measured(self, *args)

    def quadrupole(self, *args):
        return _CosmoBolognaLib.Cosmology_quadrupole(self, *args)

    def square_bulk_flow(self, *args):
        return _CosmoBolognaLib.Cosmology_square_bulk_flow(self, *args)

    def square_bulk_flow_Table(self, arg2, arg3, arg4, arg5, arg6):
        return _CosmoBolognaLib.Cosmology_square_bulk_flow_Table(self, arg2, arg3, arg4, arg5, arg6)

    def square_velocity_dispersion(self, *args):
        return _CosmoBolognaLib.Cosmology_square_velocity_dispersion(self, *args)

    def CMN(self, *args):
        return _CosmoBolognaLib.Cosmology_CMN(self, *args)

    def Sn_PT(self, *args):
        return _CosmoBolognaLib.Cosmology_Sn_PT(self, *args)

    def Sigman_PT(self, *args):
        return _CosmoBolognaLib.Cosmology_Sigman_PT(self, *args)

    def xi0_Kaiser(self, *args):
        return _CosmoBolognaLib.Cosmology_xi0_Kaiser(self, *args)

    def xi2D_DispersionModel(self, *args):
        return _CosmoBolognaLib.Cosmology_xi2D_DispersionModel(self, *args)

    def xi_star(self, *args):
        return _CosmoBolognaLib.Cosmology_xi_star(self, *args)

    def xisnl_gnw(self, *args):
        return _CosmoBolognaLib.Cosmology_xisnl_gnw(self, *args)

    def xis_gBAO(self, *args):
        return _CosmoBolognaLib.Cosmology_xis_gBAO(self, *args)

    def xi2D_CW(self, *args):
        return _CosmoBolognaLib.Cosmology_xi2D_CW(self, *args)

    def rs(self, *args):
        return _CosmoBolognaLib.Cosmology_rs(self, *args)

    def rs_EH(self, *args):
        return _CosmoBolognaLib.Cosmology_rs_EH(self, *args)

    def rs_CAMB(self):
        return _CosmoBolognaLib.Cosmology_rs_CAMB(self)

    def ys(self, *args):
        return _CosmoBolognaLib.Cosmology_ys(self, *args)

    def Az(self, arg2):
        return _CosmoBolognaLib.Cosmology_Az(self, arg2)

    def Am(self, *args):
        return _CosmoBolognaLib.Cosmology_Am(self, *args)

    def potential_spectral_amplitude(self, *args):
        return _CosmoBolognaLib.Cosmology_potential_spectral_amplitude(self, *args)

    def bispectrum(self, *args):
        return _CosmoBolognaLib.Cosmology_bispectrum(self, *args)

    def mrk(self, *args):
        return _CosmoBolognaLib.Cosmology_mrk(self, *args)

    def frk(self, *args):
        return _CosmoBolognaLib.Cosmology_frk(self, *args)

    def bias_kernel(self, arg2, arg3):
        return _CosmoBolognaLib.Cosmology_bias_kernel(self, arg2, arg3)

    def frk_test(self, *args):
        return _CosmoBolognaLib.Cosmology_frk_test(self, *args)

    def bias_correction(self, *args):
        return _CosmoBolognaLib.Cosmology_bias_correction(self, *args)

    def skewness(self, *args):
        return _CosmoBolognaLib.Cosmology_skewness(self, *args)

    def dskewnessdM(self, *args):
        return _CosmoBolognaLib.Cosmology_dskewnessdM(self, *args)

    def MF_correction(self, *args):
        return _CosmoBolognaLib.Cosmology_MF_correction(self, *args)

    def VolS(self, RR):
        return _CosmoBolognaLib.Cosmology_VolS(self, RR)

    def deltav(self, rho_vm=0.2):
        return _CosmoBolognaLib.Cosmology_deltav(self, rho_vm)

    def r_rL(self, rho_vm=0.2):
        return _CosmoBolognaLib.Cosmology_r_rL(self, rho_vm)

    def f_nu(self, SS, del_v, del_c):
        return _CosmoBolognaLib.Cosmology_f_nu(self, SS, del_v, del_c)

    def size_function(self, RV, redshift, rho_vm, del_v, del_c, method_Pk, output_root, interpType, Num, stepsize, k_max, file_par, model):
        return _CosmoBolognaLib.Cosmology_size_function(self, RV, redshift, rho_vm, del_v, del_c, method_Pk, output_root, interpType, Num, stepsize, k_max, file_par, model)

    def get_XiMonopole_covariance(self, nbins, rMin, rMax, nn, Volume, kk, Pk0, IntegrationMethod=1):
        return _CosmoBolognaLib.Cosmology_get_XiMonopole_covariance(self, nbins, rMin, rMax, nn, Volume, kk, Pk0, IntegrationMethod)

    def get_XiMultipoles(self, nbins, rMin, rMax, kk, Pk0, Pk2, Pk4, IntegrationMethod=1):
        return _CosmoBolognaLib.Cosmology_get_XiMultipoles(self, nbins, rMin, rMax, kk, Pk0, Pk2, Pk4, IntegrationMethod)

    def get_XiMultipoles_covariance(self, nbins, rMin, rMax, nn, Volume, kk, Pk0, Pk2, Pk4, IntegrationMethod=1):
        return _CosmoBolognaLib.Cosmology_get_XiMultipoles_covariance(self, nbins, rMin, rMax, nn, Volume, kk, Pk0, Pk2, Pk4, IntegrationMethod)
Cosmology_swigregister = _CosmoBolognaLib.Cosmology_swigregister
Cosmology_swigregister(Cosmology)


def GSL_bias_kernel_wrapper(arg1, arg2):
    return _CosmoBolognaLib.GSL_bias_kernel_wrapper(arg1, arg2)
GSL_bias_kernel_wrapper = _CosmoBolognaLib.GSL_bias_kernel_wrapper

def func_xi_EH_GSL(arg1, arg2):
    return _CosmoBolognaLib.func_xi_EH_GSL(arg1, arg2)
func_xi_EH_GSL = _CosmoBolognaLib.func_xi_EH_GSL

def func_SSM_EH_GSL(arg1, arg2):
    return _CosmoBolognaLib.func_SSM_EH_GSL(arg1, arg2)
func_SSM_EH_GSL = _CosmoBolognaLib.func_SSM_EH_GSL

def bias_kernel2(arg1, arg2):
    return _CosmoBolognaLib.bias_kernel2(arg1, arg2)
bias_kernel2 = _CosmoBolognaLib.bias_kernel2

def skewness_kernel(arg1, arg2, arg3):
    return _CosmoBolognaLib.skewness_kernel(arg1, arg2, arg3)
skewness_kernel = _CosmoBolognaLib.skewness_kernel
class GSL_f_pars(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GSL_f_pars, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GSL_f_pars, name)
    __repr__ = _swig_repr
    __swig_setmethods__["kt"] = _CosmoBolognaLib.GSL_f_pars_kt_set
    __swig_getmethods__["kt"] = _CosmoBolognaLib.GSL_f_pars_kt_get
    if _newclass:
        kt = _swig_property(_CosmoBolognaLib.GSL_f_pars_kt_get, _CosmoBolognaLib.GSL_f_pars_kt_set)
    __swig_setmethods__["mass"] = _CosmoBolognaLib.GSL_f_pars_mass_set
    __swig_getmethods__["mass"] = _CosmoBolognaLib.GSL_f_pars_mass_get
    if _newclass:
        mass = _swig_property(_CosmoBolognaLib.GSL_f_pars_mass_get, _CosmoBolognaLib.GSL_f_pars_mass_set)
    __swig_setmethods__["method_Pk"] = _CosmoBolognaLib.GSL_f_pars_method_Pk_set
    __swig_getmethods__["method_Pk"] = _CosmoBolognaLib.GSL_f_pars_method_Pk_get
    if _newclass:
        method_Pk = _swig_property(_CosmoBolognaLib.GSL_f_pars_method_Pk_get, _CosmoBolognaLib.GSL_f_pars_method_Pk_set)
    __swig_setmethods__["output_root"] = _CosmoBolognaLib.GSL_f_pars_output_root_set
    __swig_getmethods__["output_root"] = _CosmoBolognaLib.GSL_f_pars_output_root_get
    if _newclass:
        output_root = _swig_property(_CosmoBolognaLib.GSL_f_pars_output_root_get, _CosmoBolognaLib.GSL_f_pars_output_root_set)
    __swig_setmethods__["norm"] = _CosmoBolognaLib.GSL_f_pars_norm_set
    __swig_getmethods__["norm"] = _CosmoBolognaLib.GSL_f_pars_norm_get
    if _newclass:
        norm = _swig_property(_CosmoBolognaLib.GSL_f_pars_norm_get, _CosmoBolognaLib.GSL_f_pars_norm_set)
    __swig_setmethods__["k_min"] = _CosmoBolognaLib.GSL_f_pars_k_min_set
    __swig_getmethods__["k_min"] = _CosmoBolognaLib.GSL_f_pars_k_min_get
    if _newclass:
        k_min = _swig_property(_CosmoBolognaLib.GSL_f_pars_k_min_get, _CosmoBolognaLib.GSL_f_pars_k_min_set)
    __swig_setmethods__["k_max"] = _CosmoBolognaLib.GSL_f_pars_k_max_set
    __swig_getmethods__["k_max"] = _CosmoBolognaLib.GSL_f_pars_k_max_get
    if _newclass:
        k_max = _swig_property(_CosmoBolognaLib.GSL_f_pars_k_max_get, _CosmoBolognaLib.GSL_f_pars_k_max_set)
    __swig_setmethods__["GSL"] = _CosmoBolognaLib.GSL_f_pars_GSL_set
    __swig_getmethods__["GSL"] = _CosmoBolognaLib.GSL_f_pars_GSL_get
    if _newclass:
        GSL = _swig_property(_CosmoBolognaLib.GSL_f_pars_GSL_get, _CosmoBolognaLib.GSL_f_pars_GSL_set)
    __swig_setmethods__["prec"] = _CosmoBolognaLib.GSL_f_pars_prec_set
    __swig_getmethods__["prec"] = _CosmoBolognaLib.GSL_f_pars_prec_get
    if _newclass:
        prec = _swig_property(_CosmoBolognaLib.GSL_f_pars_prec_get, _CosmoBolognaLib.GSL_f_pars_prec_set)
    __swig_setmethods__["file_par"] = _CosmoBolognaLib.GSL_f_pars_file_par_set
    __swig_getmethods__["file_par"] = _CosmoBolognaLib.GSL_f_pars_file_par_get
    if _newclass:
        file_par = _swig_property(_CosmoBolognaLib.GSL_f_pars_file_par_get, _CosmoBolognaLib.GSL_f_pars_file_par_set)
    __swig_setmethods__["pt_Cosmology"] = _CosmoBolognaLib.GSL_f_pars_pt_Cosmology_set
    __swig_getmethods__["pt_Cosmology"] = _CosmoBolognaLib.GSL_f_pars_pt_Cosmology_get
    if _newclass:
        pt_Cosmology = _swig_property(_CosmoBolognaLib.GSL_f_pars_pt_Cosmology_get, _CosmoBolognaLib.GSL_f_pars_pt_Cosmology_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_GSL_f_pars()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_GSL_f_pars
    __del__ = lambda self: None
GSL_f_pars_swigregister = _CosmoBolognaLib.GSL_f_pars_swigregister
GSL_f_pars_swigregister(GSL_f_pars)

class STR_xi_EH(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, STR_xi_EH, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, STR_xi_EH, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Omega_matter"] = _CosmoBolognaLib.STR_xi_EH_Omega_matter_set
    __swig_getmethods__["Omega_matter"] = _CosmoBolognaLib.STR_xi_EH_Omega_matter_get
    if _newclass:
        Omega_matter = _swig_property(_CosmoBolognaLib.STR_xi_EH_Omega_matter_get, _CosmoBolognaLib.STR_xi_EH_Omega_matter_set)
    __swig_setmethods__["Omega_baryon"] = _CosmoBolognaLib.STR_xi_EH_Omega_baryon_set
    __swig_getmethods__["Omega_baryon"] = _CosmoBolognaLib.STR_xi_EH_Omega_baryon_get
    if _newclass:
        Omega_baryon = _swig_property(_CosmoBolognaLib.STR_xi_EH_Omega_baryon_get, _CosmoBolognaLib.STR_xi_EH_Omega_baryon_set)
    __swig_setmethods__["Omega_neutrinos"] = _CosmoBolognaLib.STR_xi_EH_Omega_neutrinos_set
    __swig_getmethods__["Omega_neutrinos"] = _CosmoBolognaLib.STR_xi_EH_Omega_neutrinos_get
    if _newclass:
        Omega_neutrinos = _swig_property(_CosmoBolognaLib.STR_xi_EH_Omega_neutrinos_get, _CosmoBolognaLib.STR_xi_EH_Omega_neutrinos_set)
    __swig_setmethods__["massless_neutrinos"] = _CosmoBolognaLib.STR_xi_EH_massless_neutrinos_set
    __swig_getmethods__["massless_neutrinos"] = _CosmoBolognaLib.STR_xi_EH_massless_neutrinos_get
    if _newclass:
        massless_neutrinos = _swig_property(_CosmoBolognaLib.STR_xi_EH_massless_neutrinos_get, _CosmoBolognaLib.STR_xi_EH_massless_neutrinos_set)
    __swig_setmethods__["massive_neutrinos"] = _CosmoBolognaLib.STR_xi_EH_massive_neutrinos_set
    __swig_getmethods__["massive_neutrinos"] = _CosmoBolognaLib.STR_xi_EH_massive_neutrinos_get
    if _newclass:
        massive_neutrinos = _swig_property(_CosmoBolognaLib.STR_xi_EH_massive_neutrinos_get, _CosmoBolognaLib.STR_xi_EH_massive_neutrinos_set)
    __swig_setmethods__["Omega_DE"] = _CosmoBolognaLib.STR_xi_EH_Omega_DE_set
    __swig_getmethods__["Omega_DE"] = _CosmoBolognaLib.STR_xi_EH_Omega_DE_get
    if _newclass:
        Omega_DE = _swig_property(_CosmoBolognaLib.STR_xi_EH_Omega_DE_get, _CosmoBolognaLib.STR_xi_EH_Omega_DE_set)
    __swig_setmethods__["Omega_radiation"] = _CosmoBolognaLib.STR_xi_EH_Omega_radiation_set
    __swig_getmethods__["Omega_radiation"] = _CosmoBolognaLib.STR_xi_EH_Omega_radiation_get
    if _newclass:
        Omega_radiation = _swig_property(_CosmoBolognaLib.STR_xi_EH_Omega_radiation_get, _CosmoBolognaLib.STR_xi_EH_Omega_radiation_set)
    __swig_setmethods__["hh"] = _CosmoBolognaLib.STR_xi_EH_hh_set
    __swig_getmethods__["hh"] = _CosmoBolognaLib.STR_xi_EH_hh_get
    if _newclass:
        hh = _swig_property(_CosmoBolognaLib.STR_xi_EH_hh_get, _CosmoBolognaLib.STR_xi_EH_hh_set)
    __swig_setmethods__["scalar_amp"] = _CosmoBolognaLib.STR_xi_EH_scalar_amp_set
    __swig_getmethods__["scalar_amp"] = _CosmoBolognaLib.STR_xi_EH_scalar_amp_get
    if _newclass:
        scalar_amp = _swig_property(_CosmoBolognaLib.STR_xi_EH_scalar_amp_get, _CosmoBolognaLib.STR_xi_EH_scalar_amp_set)
    __swig_setmethods__["n_spec"] = _CosmoBolognaLib.STR_xi_EH_n_spec_set
    __swig_getmethods__["n_spec"] = _CosmoBolognaLib.STR_xi_EH_n_spec_get
    if _newclass:
        n_spec = _swig_property(_CosmoBolognaLib.STR_xi_EH_n_spec_get, _CosmoBolognaLib.STR_xi_EH_n_spec_set)
    __swig_setmethods__["w0"] = _CosmoBolognaLib.STR_xi_EH_w0_set
    __swig_getmethods__["w0"] = _CosmoBolognaLib.STR_xi_EH_w0_get
    if _newclass:
        w0 = _swig_property(_CosmoBolognaLib.STR_xi_EH_w0_get, _CosmoBolognaLib.STR_xi_EH_w0_set)
    __swig_setmethods__["wa"] = _CosmoBolognaLib.STR_xi_EH_wa_set
    __swig_getmethods__["wa"] = _CosmoBolognaLib.STR_xi_EH_wa_get
    if _newclass:
        wa = _swig_property(_CosmoBolognaLib.STR_xi_EH_wa_get, _CosmoBolognaLib.STR_xi_EH_wa_set)
    __swig_setmethods__["fNL"] = _CosmoBolognaLib.STR_xi_EH_fNL_set
    __swig_getmethods__["fNL"] = _CosmoBolognaLib.STR_xi_EH_fNL_get
    if _newclass:
        fNL = _swig_property(_CosmoBolognaLib.STR_xi_EH_fNL_get, _CosmoBolognaLib.STR_xi_EH_fNL_set)
    __swig_setmethods__["type_NG"] = _CosmoBolognaLib.STR_xi_EH_type_NG_set
    __swig_getmethods__["type_NG"] = _CosmoBolognaLib.STR_xi_EH_type_NG_get
    if _newclass:
        type_NG = _swig_property(_CosmoBolognaLib.STR_xi_EH_type_NG_get, _CosmoBolognaLib.STR_xi_EH_type_NG_set)
    __swig_setmethods__["model"] = _CosmoBolognaLib.STR_xi_EH_model_set
    __swig_getmethods__["model"] = _CosmoBolognaLib.STR_xi_EH_model_get
    if _newclass:
        model = _swig_property(_CosmoBolognaLib.STR_xi_EH_model_get, _CosmoBolognaLib.STR_xi_EH_model_set)
    __swig_setmethods__["unit"] = _CosmoBolognaLib.STR_xi_EH_unit_set
    __swig_getmethods__["unit"] = _CosmoBolognaLib.STR_xi_EH_unit_get
    if _newclass:
        unit = _swig_property(_CosmoBolognaLib.STR_xi_EH_unit_get, _CosmoBolognaLib.STR_xi_EH_unit_set)
    __swig_setmethods__["method_Pk"] = _CosmoBolognaLib.STR_xi_EH_method_Pk_set
    __swig_getmethods__["method_Pk"] = _CosmoBolognaLib.STR_xi_EH_method_Pk_get
    if _newclass:
        method_Pk = _swig_property(_CosmoBolognaLib.STR_xi_EH_method_Pk_get, _CosmoBolognaLib.STR_xi_EH_method_Pk_set)
    __swig_setmethods__["rr"] = _CosmoBolognaLib.STR_xi_EH_rr_set
    __swig_getmethods__["rr"] = _CosmoBolognaLib.STR_xi_EH_rr_get
    if _newclass:
        rr = _swig_property(_CosmoBolognaLib.STR_xi_EH_rr_get, _CosmoBolognaLib.STR_xi_EH_rr_set)
    __swig_setmethods__["redshift"] = _CosmoBolognaLib.STR_xi_EH_redshift_set
    __swig_getmethods__["redshift"] = _CosmoBolognaLib.STR_xi_EH_redshift_get
    if _newclass:
        redshift = _swig_property(_CosmoBolognaLib.STR_xi_EH_redshift_get, _CosmoBolognaLib.STR_xi_EH_redshift_set)
    __swig_setmethods__["aa"] = _CosmoBolognaLib.STR_xi_EH_aa_set
    __swig_getmethods__["aa"] = _CosmoBolognaLib.STR_xi_EH_aa_get
    if _newclass:
        aa = _swig_property(_CosmoBolognaLib.STR_xi_EH_aa_get, _CosmoBolognaLib.STR_xi_EH_aa_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_STR_xi_EH()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_STR_xi_EH
    __del__ = lambda self: None
STR_xi_EH_swigregister = _CosmoBolognaLib.STR_xi_EH_swigregister
STR_xi_EH_swigregister(STR_xi_EH)

class STR_SSM_EH(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, STR_SSM_EH, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, STR_SSM_EH, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Omega_matter"] = _CosmoBolognaLib.STR_SSM_EH_Omega_matter_set
    __swig_getmethods__["Omega_matter"] = _CosmoBolognaLib.STR_SSM_EH_Omega_matter_get
    if _newclass:
        Omega_matter = _swig_property(_CosmoBolognaLib.STR_SSM_EH_Omega_matter_get, _CosmoBolognaLib.STR_SSM_EH_Omega_matter_set)
    __swig_setmethods__["Omega_baryon"] = _CosmoBolognaLib.STR_SSM_EH_Omega_baryon_set
    __swig_getmethods__["Omega_baryon"] = _CosmoBolognaLib.STR_SSM_EH_Omega_baryon_get
    if _newclass:
        Omega_baryon = _swig_property(_CosmoBolognaLib.STR_SSM_EH_Omega_baryon_get, _CosmoBolognaLib.STR_SSM_EH_Omega_baryon_set)
    __swig_setmethods__["Omega_neutrinos"] = _CosmoBolognaLib.STR_SSM_EH_Omega_neutrinos_set
    __swig_getmethods__["Omega_neutrinos"] = _CosmoBolognaLib.STR_SSM_EH_Omega_neutrinos_get
    if _newclass:
        Omega_neutrinos = _swig_property(_CosmoBolognaLib.STR_SSM_EH_Omega_neutrinos_get, _CosmoBolognaLib.STR_SSM_EH_Omega_neutrinos_set)
    __swig_setmethods__["massless_neutrinos"] = _CosmoBolognaLib.STR_SSM_EH_massless_neutrinos_set
    __swig_getmethods__["massless_neutrinos"] = _CosmoBolognaLib.STR_SSM_EH_massless_neutrinos_get
    if _newclass:
        massless_neutrinos = _swig_property(_CosmoBolognaLib.STR_SSM_EH_massless_neutrinos_get, _CosmoBolognaLib.STR_SSM_EH_massless_neutrinos_set)
    __swig_setmethods__["massive_neutrinos"] = _CosmoBolognaLib.STR_SSM_EH_massive_neutrinos_set
    __swig_getmethods__["massive_neutrinos"] = _CosmoBolognaLib.STR_SSM_EH_massive_neutrinos_get
    if _newclass:
        massive_neutrinos = _swig_property(_CosmoBolognaLib.STR_SSM_EH_massive_neutrinos_get, _CosmoBolognaLib.STR_SSM_EH_massive_neutrinos_set)
    __swig_setmethods__["Omega_DE"] = _CosmoBolognaLib.STR_SSM_EH_Omega_DE_set
    __swig_getmethods__["Omega_DE"] = _CosmoBolognaLib.STR_SSM_EH_Omega_DE_get
    if _newclass:
        Omega_DE = _swig_property(_CosmoBolognaLib.STR_SSM_EH_Omega_DE_get, _CosmoBolognaLib.STR_SSM_EH_Omega_DE_set)
    __swig_setmethods__["Omega_radiation"] = _CosmoBolognaLib.STR_SSM_EH_Omega_radiation_set
    __swig_getmethods__["Omega_radiation"] = _CosmoBolognaLib.STR_SSM_EH_Omega_radiation_get
    if _newclass:
        Omega_radiation = _swig_property(_CosmoBolognaLib.STR_SSM_EH_Omega_radiation_get, _CosmoBolognaLib.STR_SSM_EH_Omega_radiation_set)
    __swig_setmethods__["hh"] = _CosmoBolognaLib.STR_SSM_EH_hh_set
    __swig_getmethods__["hh"] = _CosmoBolognaLib.STR_SSM_EH_hh_get
    if _newclass:
        hh = _swig_property(_CosmoBolognaLib.STR_SSM_EH_hh_get, _CosmoBolognaLib.STR_SSM_EH_hh_set)
    __swig_setmethods__["scalar_amp"] = _CosmoBolognaLib.STR_SSM_EH_scalar_amp_set
    __swig_getmethods__["scalar_amp"] = _CosmoBolognaLib.STR_SSM_EH_scalar_amp_get
    if _newclass:
        scalar_amp = _swig_property(_CosmoBolognaLib.STR_SSM_EH_scalar_amp_get, _CosmoBolognaLib.STR_SSM_EH_scalar_amp_set)
    __swig_setmethods__["n_spec"] = _CosmoBolognaLib.STR_SSM_EH_n_spec_set
    __swig_getmethods__["n_spec"] = _CosmoBolognaLib.STR_SSM_EH_n_spec_get
    if _newclass:
        n_spec = _swig_property(_CosmoBolognaLib.STR_SSM_EH_n_spec_get, _CosmoBolognaLib.STR_SSM_EH_n_spec_set)
    __swig_setmethods__["w0"] = _CosmoBolognaLib.STR_SSM_EH_w0_set
    __swig_getmethods__["w0"] = _CosmoBolognaLib.STR_SSM_EH_w0_get
    if _newclass:
        w0 = _swig_property(_CosmoBolognaLib.STR_SSM_EH_w0_get, _CosmoBolognaLib.STR_SSM_EH_w0_set)
    __swig_setmethods__["wa"] = _CosmoBolognaLib.STR_SSM_EH_wa_set
    __swig_getmethods__["wa"] = _CosmoBolognaLib.STR_SSM_EH_wa_get
    if _newclass:
        wa = _swig_property(_CosmoBolognaLib.STR_SSM_EH_wa_get, _CosmoBolognaLib.STR_SSM_EH_wa_set)
    __swig_setmethods__["fNL"] = _CosmoBolognaLib.STR_SSM_EH_fNL_set
    __swig_getmethods__["fNL"] = _CosmoBolognaLib.STR_SSM_EH_fNL_get
    if _newclass:
        fNL = _swig_property(_CosmoBolognaLib.STR_SSM_EH_fNL_get, _CosmoBolognaLib.STR_SSM_EH_fNL_set)
    __swig_setmethods__["type_NG"] = _CosmoBolognaLib.STR_SSM_EH_type_NG_set
    __swig_getmethods__["type_NG"] = _CosmoBolognaLib.STR_SSM_EH_type_NG_get
    if _newclass:
        type_NG = _swig_property(_CosmoBolognaLib.STR_SSM_EH_type_NG_get, _CosmoBolognaLib.STR_SSM_EH_type_NG_set)
    __swig_setmethods__["model"] = _CosmoBolognaLib.STR_SSM_EH_model_set
    __swig_getmethods__["model"] = _CosmoBolognaLib.STR_SSM_EH_model_get
    if _newclass:
        model = _swig_property(_CosmoBolognaLib.STR_SSM_EH_model_get, _CosmoBolognaLib.STR_SSM_EH_model_set)
    __swig_setmethods__["unit"] = _CosmoBolognaLib.STR_SSM_EH_unit_set
    __swig_getmethods__["unit"] = _CosmoBolognaLib.STR_SSM_EH_unit_get
    if _newclass:
        unit = _swig_property(_CosmoBolognaLib.STR_SSM_EH_unit_get, _CosmoBolognaLib.STR_SSM_EH_unit_set)
    __swig_setmethods__["method_Pk"] = _CosmoBolognaLib.STR_SSM_EH_method_Pk_set
    __swig_getmethods__["method_Pk"] = _CosmoBolognaLib.STR_SSM_EH_method_Pk_get
    if _newclass:
        method_Pk = _swig_property(_CosmoBolognaLib.STR_SSM_EH_method_Pk_get, _CosmoBolognaLib.STR_SSM_EH_method_Pk_set)
    __swig_setmethods__["redshift"] = _CosmoBolognaLib.STR_SSM_EH_redshift_set
    __swig_getmethods__["redshift"] = _CosmoBolognaLib.STR_SSM_EH_redshift_get
    if _newclass:
        redshift = _swig_property(_CosmoBolognaLib.STR_SSM_EH_redshift_get, _CosmoBolognaLib.STR_SSM_EH_redshift_set)
    __swig_setmethods__["mass"] = _CosmoBolognaLib.STR_SSM_EH_mass_set
    __swig_getmethods__["mass"] = _CosmoBolognaLib.STR_SSM_EH_mass_get
    if _newclass:
        mass = _swig_property(_CosmoBolognaLib.STR_SSM_EH_mass_get, _CosmoBolognaLib.STR_SSM_EH_mass_set)
    __swig_setmethods__["rho"] = _CosmoBolognaLib.STR_SSM_EH_rho_set
    __swig_getmethods__["rho"] = _CosmoBolognaLib.STR_SSM_EH_rho_get
    if _newclass:
        rho = _swig_property(_CosmoBolognaLib.STR_SSM_EH_rho_get, _CosmoBolognaLib.STR_SSM_EH_rho_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_STR_SSM_EH()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_STR_SSM_EH
    __del__ = lambda self: None
STR_SSM_EH_swigregister = _CosmoBolognaLib.STR_SSM_EH_swigregister
STR_SSM_EH_swigregister(STR_SSM_EH)

class STR_NG(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, STR_NG, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, STR_NG, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Omega_matter"] = _CosmoBolognaLib.STR_NG_Omega_matter_set
    __swig_getmethods__["Omega_matter"] = _CosmoBolognaLib.STR_NG_Omega_matter_get
    if _newclass:
        Omega_matter = _swig_property(_CosmoBolognaLib.STR_NG_Omega_matter_get, _CosmoBolognaLib.STR_NG_Omega_matter_set)
    __swig_setmethods__["Omega_baryon"] = _CosmoBolognaLib.STR_NG_Omega_baryon_set
    __swig_getmethods__["Omega_baryon"] = _CosmoBolognaLib.STR_NG_Omega_baryon_get
    if _newclass:
        Omega_baryon = _swig_property(_CosmoBolognaLib.STR_NG_Omega_baryon_get, _CosmoBolognaLib.STR_NG_Omega_baryon_set)
    __swig_setmethods__["Omega_neutrinos"] = _CosmoBolognaLib.STR_NG_Omega_neutrinos_set
    __swig_getmethods__["Omega_neutrinos"] = _CosmoBolognaLib.STR_NG_Omega_neutrinos_get
    if _newclass:
        Omega_neutrinos = _swig_property(_CosmoBolognaLib.STR_NG_Omega_neutrinos_get, _CosmoBolognaLib.STR_NG_Omega_neutrinos_set)
    __swig_setmethods__["massless_neutrinos"] = _CosmoBolognaLib.STR_NG_massless_neutrinos_set
    __swig_getmethods__["massless_neutrinos"] = _CosmoBolognaLib.STR_NG_massless_neutrinos_get
    if _newclass:
        massless_neutrinos = _swig_property(_CosmoBolognaLib.STR_NG_massless_neutrinos_get, _CosmoBolognaLib.STR_NG_massless_neutrinos_set)
    __swig_setmethods__["massive_neutrinos"] = _CosmoBolognaLib.STR_NG_massive_neutrinos_set
    __swig_getmethods__["massive_neutrinos"] = _CosmoBolognaLib.STR_NG_massive_neutrinos_get
    if _newclass:
        massive_neutrinos = _swig_property(_CosmoBolognaLib.STR_NG_massive_neutrinos_get, _CosmoBolognaLib.STR_NG_massive_neutrinos_set)
    __swig_setmethods__["Omega_DE"] = _CosmoBolognaLib.STR_NG_Omega_DE_set
    __swig_getmethods__["Omega_DE"] = _CosmoBolognaLib.STR_NG_Omega_DE_get
    if _newclass:
        Omega_DE = _swig_property(_CosmoBolognaLib.STR_NG_Omega_DE_get, _CosmoBolognaLib.STR_NG_Omega_DE_set)
    __swig_setmethods__["Omega_radiation"] = _CosmoBolognaLib.STR_NG_Omega_radiation_set
    __swig_getmethods__["Omega_radiation"] = _CosmoBolognaLib.STR_NG_Omega_radiation_get
    if _newclass:
        Omega_radiation = _swig_property(_CosmoBolognaLib.STR_NG_Omega_radiation_get, _CosmoBolognaLib.STR_NG_Omega_radiation_set)
    __swig_setmethods__["hh"] = _CosmoBolognaLib.STR_NG_hh_set
    __swig_getmethods__["hh"] = _CosmoBolognaLib.STR_NG_hh_get
    if _newclass:
        hh = _swig_property(_CosmoBolognaLib.STR_NG_hh_get, _CosmoBolognaLib.STR_NG_hh_set)
    __swig_setmethods__["scalar_amp"] = _CosmoBolognaLib.STR_NG_scalar_amp_set
    __swig_getmethods__["scalar_amp"] = _CosmoBolognaLib.STR_NG_scalar_amp_get
    if _newclass:
        scalar_amp = _swig_property(_CosmoBolognaLib.STR_NG_scalar_amp_get, _CosmoBolognaLib.STR_NG_scalar_amp_set)
    __swig_setmethods__["n_spec"] = _CosmoBolognaLib.STR_NG_n_spec_set
    __swig_getmethods__["n_spec"] = _CosmoBolognaLib.STR_NG_n_spec_get
    if _newclass:
        n_spec = _swig_property(_CosmoBolognaLib.STR_NG_n_spec_get, _CosmoBolognaLib.STR_NG_n_spec_set)
    __swig_setmethods__["w0"] = _CosmoBolognaLib.STR_NG_w0_set
    __swig_getmethods__["w0"] = _CosmoBolognaLib.STR_NG_w0_get
    if _newclass:
        w0 = _swig_property(_CosmoBolognaLib.STR_NG_w0_get, _CosmoBolognaLib.STR_NG_w0_set)
    __swig_setmethods__["wa"] = _CosmoBolognaLib.STR_NG_wa_set
    __swig_getmethods__["wa"] = _CosmoBolognaLib.STR_NG_wa_get
    if _newclass:
        wa = _swig_property(_CosmoBolognaLib.STR_NG_wa_get, _CosmoBolognaLib.STR_NG_wa_set)
    __swig_setmethods__["fNL"] = _CosmoBolognaLib.STR_NG_fNL_set
    __swig_getmethods__["fNL"] = _CosmoBolognaLib.STR_NG_fNL_get
    if _newclass:
        fNL = _swig_property(_CosmoBolognaLib.STR_NG_fNL_get, _CosmoBolognaLib.STR_NG_fNL_set)
    __swig_setmethods__["type_NG"] = _CosmoBolognaLib.STR_NG_type_NG_set
    __swig_getmethods__["type_NG"] = _CosmoBolognaLib.STR_NG_type_NG_get
    if _newclass:
        type_NG = _swig_property(_CosmoBolognaLib.STR_NG_type_NG_get, _CosmoBolognaLib.STR_NG_type_NG_set)
    __swig_setmethods__["model"] = _CosmoBolognaLib.STR_NG_model_set
    __swig_getmethods__["model"] = _CosmoBolognaLib.STR_NG_model_get
    if _newclass:
        model = _swig_property(_CosmoBolognaLib.STR_NG_model_get, _CosmoBolognaLib.STR_NG_model_set)
    __swig_setmethods__["unit"] = _CosmoBolognaLib.STR_NG_unit_set
    __swig_getmethods__["unit"] = _CosmoBolognaLib.STR_NG_unit_get
    if _newclass:
        unit = _swig_property(_CosmoBolognaLib.STR_NG_unit_get, _CosmoBolognaLib.STR_NG_unit_set)
    __swig_setmethods__["kt"] = _CosmoBolognaLib.STR_NG_kt_set
    __swig_getmethods__["kt"] = _CosmoBolognaLib.STR_NG_kt_get
    if _newclass:
        kt = _swig_property(_CosmoBolognaLib.STR_NG_kt_get, _CosmoBolognaLib.STR_NG_kt_set)
    __swig_setmethods__["mass"] = _CosmoBolognaLib.STR_NG_mass_set
    __swig_getmethods__["mass"] = _CosmoBolognaLib.STR_NG_mass_get
    if _newclass:
        mass = _swig_property(_CosmoBolognaLib.STR_NG_mass_get, _CosmoBolognaLib.STR_NG_mass_set)
    __swig_setmethods__["method_Pk"] = _CosmoBolognaLib.STR_NG_method_Pk_set
    __swig_getmethods__["method_Pk"] = _CosmoBolognaLib.STR_NG_method_Pk_get
    if _newclass:
        method_Pk = _swig_property(_CosmoBolognaLib.STR_NG_method_Pk_get, _CosmoBolognaLib.STR_NG_method_Pk_set)
    __swig_setmethods__["output_root"] = _CosmoBolognaLib.STR_NG_output_root_set
    __swig_getmethods__["output_root"] = _CosmoBolognaLib.STR_NG_output_root_get
    if _newclass:
        output_root = _swig_property(_CosmoBolognaLib.STR_NG_output_root_get, _CosmoBolognaLib.STR_NG_output_root_set)
    __swig_setmethods__["norm"] = _CosmoBolognaLib.STR_NG_norm_set
    __swig_getmethods__["norm"] = _CosmoBolognaLib.STR_NG_norm_get
    if _newclass:
        norm = _swig_property(_CosmoBolognaLib.STR_NG_norm_get, _CosmoBolognaLib.STR_NG_norm_set)
    __swig_setmethods__["k_min"] = _CosmoBolognaLib.STR_NG_k_min_set
    __swig_getmethods__["k_min"] = _CosmoBolognaLib.STR_NG_k_min_get
    if _newclass:
        k_min = _swig_property(_CosmoBolognaLib.STR_NG_k_min_get, _CosmoBolognaLib.STR_NG_k_min_set)
    __swig_setmethods__["k_max"] = _CosmoBolognaLib.STR_NG_k_max_set
    __swig_getmethods__["k_max"] = _CosmoBolognaLib.STR_NG_k_max_get
    if _newclass:
        k_max = _swig_property(_CosmoBolognaLib.STR_NG_k_max_get, _CosmoBolognaLib.STR_NG_k_max_set)
    __swig_setmethods__["GSL"] = _CosmoBolognaLib.STR_NG_GSL_set
    __swig_getmethods__["GSL"] = _CosmoBolognaLib.STR_NG_GSL_get
    if _newclass:
        GSL = _swig_property(_CosmoBolognaLib.STR_NG_GSL_get, _CosmoBolognaLib.STR_NG_GSL_set)
    __swig_setmethods__["prec"] = _CosmoBolognaLib.STR_NG_prec_set
    __swig_getmethods__["prec"] = _CosmoBolognaLib.STR_NG_prec_get
    if _newclass:
        prec = _swig_property(_CosmoBolognaLib.STR_NG_prec_get, _CosmoBolognaLib.STR_NG_prec_set)
    __swig_setmethods__["file_par"] = _CosmoBolognaLib.STR_NG_file_par_set
    __swig_getmethods__["file_par"] = _CosmoBolognaLib.STR_NG_file_par_get
    if _newclass:
        file_par = _swig_property(_CosmoBolognaLib.STR_NG_file_par_get, _CosmoBolognaLib.STR_NG_file_par_set)

    def __init__(self):
        this = _CosmoBolognaLib.new_STR_NG()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_STR_NG
    __del__ = lambda self: None
STR_NG_swigregister = _CosmoBolognaLib.STR_NG_swigregister
STR_NG_swigregister(STR_NG)

class ChainMesh(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChainMesh, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChainMesh, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_ChainMesh(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_ChainMesh
    __del__ = lambda self: None

    def set_par(self, cell_size, nDim):
        return _CosmoBolognaLib.ChainMesh_set_par(self, cell_size, nDim)

    def nCell(self):
        return _CosmoBolognaLib.ChainMesh_nCell(self)

    def pos_to_index(self, center):
        return _CosmoBolognaLib.ChainMesh_pos_to_index(self, center)

    def inds_to_index(self, indx):
        return _CosmoBolognaLib.ChainMesh_inds_to_index(self, indx)

    def index_to_inds(self, index, nn, indx):
        return _CosmoBolognaLib.ChainMesh_index_to_inds(self, index, nn, indx)

    def create_chain_mesh(self, data, rMax, nMIN=0, nMAX=300):
        return _CosmoBolognaLib.ChainMesh_create_chain_mesh(self, data, rMax, nMIN, nMAX)

    def create_chain_mesh_m2(self, data):
        return _CosmoBolognaLib.ChainMesh_create_chain_mesh_m2(self, data)

    def get_searching_region(self, r_max, r_min=-1):
        return _CosmoBolognaLib.ChainMesh_get_searching_region(self, r_max, r_min)

    def close_objects(self, center, ii=-1):
        return _CosmoBolognaLib.ChainMesh_close_objects(self, center, ii)

    def get_list(self, cell_index):
        return _CosmoBolognaLib.ChainMesh_get_list(self, cell_index)
ChainMesh_swigregister = _CosmoBolognaLib.ChainMesh_swigregister
ChainMesh_swigregister(ChainMesh)

class ChainMesh1D(ChainMesh):
    __swig_setmethods__ = {}
    for _s in [ChainMesh]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChainMesh1D, name, value)
    __swig_getmethods__ = {}
    for _s in [ChainMesh]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChainMesh1D, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_ChainMesh1D
    __del__ = lambda self: None

    def set_par(self, cell_size, xx, rMAX, nMIN=0, nMAX=300):
        return _CosmoBolognaLib.ChainMesh1D_set_par(self, cell_size, xx, rMAX, nMIN, nMAX)

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_ChainMesh1D(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
ChainMesh1D_swigregister = _CosmoBolognaLib.ChainMesh1D_swigregister
ChainMesh1D_swigregister(ChainMesh1D)

class ChainMesh2D(ChainMesh):
    __swig_setmethods__ = {}
    for _s in [ChainMesh]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChainMesh2D, name, value)
    __swig_getmethods__ = {}
    for _s in [ChainMesh]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChainMesh2D, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_ChainMesh2D
    __del__ = lambda self: None

    def set_par(self, cell_size, xx, yy, rMAX, nMIN=0, nMAX=300):
        return _CosmoBolognaLib.ChainMesh2D_set_par(self, cell_size, xx, yy, rMAX, nMIN, nMAX)

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_ChainMesh2D(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
ChainMesh2D_swigregister = _CosmoBolognaLib.ChainMesh2D_swigregister
ChainMesh2D_swigregister(ChainMesh2D)

class ChainMesh3D(ChainMesh):
    __swig_setmethods__ = {}
    for _s in [ChainMesh]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChainMesh3D, name, value)
    __swig_getmethods__ = {}
    for _s in [ChainMesh]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChainMesh3D, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_ChainMesh3D
    __del__ = lambda self: None

    def set_par(self, cell_size, xx, yy, zz, rMAX, nMIN=0, nMAX=300):
        return _CosmoBolognaLib.ChainMesh3D_set_par(self, cell_size, xx, yy, zz, rMAX, nMIN, nMAX)

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_ChainMesh3D(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
ChainMesh3D_swigregister = _CosmoBolognaLib.ChainMesh3D_swigregister
ChainMesh3D_swigregister(ChainMesh3D)


_CosmoBolognaLib._GenericObject__swigconstant(_CosmoBolognaLib)
_GenericObject_ = _CosmoBolognaLib._GenericObject_

_CosmoBolognaLib._RandomObject__swigconstant(_CosmoBolognaLib)
_RandomObject_ = _CosmoBolognaLib._RandomObject_

_CosmoBolognaLib._Mock__swigconstant(_CosmoBolognaLib)
_Mock_ = _CosmoBolognaLib._Mock_

_CosmoBolognaLib._Halo__swigconstant(_CosmoBolognaLib)
_Halo_ = _CosmoBolognaLib._Halo_

_CosmoBolognaLib._Galaxy__swigconstant(_CosmoBolognaLib)
_Galaxy_ = _CosmoBolognaLib._Galaxy_

_CosmoBolognaLib._Cluster__swigconstant(_CosmoBolognaLib)
_Cluster_ = _CosmoBolognaLib._Cluster_

_CosmoBolognaLib._Void__swigconstant(_CosmoBolognaLib)
_Void_ = _CosmoBolognaLib._Void_
class Object(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Object, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Object, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Object(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Object
    __del__ = lambda self: None
    __swig_getmethods__["Create"] = lambda x: _CosmoBolognaLib.Object_Create
    if _newclass:
        Create = staticmethod(_CosmoBolognaLib.Object_Create)

    def xx(self):
        return _CosmoBolognaLib.Object_xx(self)

    def yy(self):
        return _CosmoBolognaLib.Object_yy(self)

    def zz(self):
        return _CosmoBolognaLib.Object_zz(self)

    def dc(self):
        return _CosmoBolognaLib.Object_dc(self)

    def ra(self):
        return _CosmoBolognaLib.Object_ra(self)

    def dec(self):
        return _CosmoBolognaLib.Object_dec(self)

    def redshift(self):
        return _CosmoBolognaLib.Object_redshift(self)

    def weight(self):
        return _CosmoBolognaLib.Object_weight(self)

    def region(self):
        return _CosmoBolognaLib.Object_region(self)

    def field(self):
        return _CosmoBolognaLib.Object_field(self)

    def x_displacement(self):
        return _CosmoBolognaLib.Object_x_displacement(self)

    def y_displacement(self):
        return _CosmoBolognaLib.Object_y_displacement(self)

    def z_displacement(self):
        return _CosmoBolognaLib.Object_z_displacement(self)

    def coords(self):
        return _CosmoBolognaLib.Object_coords(self)

    def vx(self):
        return _CosmoBolognaLib.Object_vx(self)

    def vy(self):
        return _CosmoBolognaLib.Object_vy(self)

    def vz(self):
        return _CosmoBolognaLib.Object_vz(self)

    def mass(self):
        return _CosmoBolognaLib.Object_mass(self)

    def magnitude(self):
        return _CosmoBolognaLib.Object_magnitude(self)

    def richness(self):
        return _CosmoBolognaLib.Object_richness(self)

    def generic(self):
        return _CosmoBolognaLib.Object_generic(self)

    def radius(self):
        return _CosmoBolognaLib.Object_radius(self)

    def set_xx(self, *args):
        return _CosmoBolognaLib.Object_set_xx(self, *args)

    def set_yy(self, *args):
        return _CosmoBolognaLib.Object_set_yy(self, *args)

    def set_zz(self, *args):
        return _CosmoBolognaLib.Object_set_zz(self, *args)

    def set_ra(self, *args):
        return _CosmoBolognaLib.Object_set_ra(self, *args)

    def set_dec(self, *args):
        return _CosmoBolognaLib.Object_set_dec(self, *args)

    def set_redshift(self, *args):
        return _CosmoBolognaLib.Object_set_redshift(self, *args)

    def set_dc(self, *args):
        return _CosmoBolognaLib.Object_set_dc(self, *args)

    def set_weight(self, *args):
        return _CosmoBolognaLib.Object_set_weight(self, *args)

    def set_region(self, *args):
        return _CosmoBolognaLib.Object_set_region(self, *args)

    def set_field(self, *args):
        return _CosmoBolognaLib.Object_set_field(self, *args)

    def set_x_displacement(self, *args):
        return _CosmoBolognaLib.Object_set_x_displacement(self, *args)

    def set_y_displacement(self, *args):
        return _CosmoBolognaLib.Object_set_y_displacement(self, *args)

    def set_z_displacement(self, *args):
        return _CosmoBolognaLib.Object_set_z_displacement(self, *args)

    def set_vx(self, *args):
        return _CosmoBolognaLib.Object_set_vx(self, *args)

    def set_vy(self, *args):
        return _CosmoBolognaLib.Object_set_vy(self, *args)

    def set_vz(self, *args):
        return _CosmoBolognaLib.Object_set_vz(self, *args)

    def set_mass(self, *args):
        return _CosmoBolognaLib.Object_set_mass(self, *args)

    def set_magnitude(self, *args):
        return _CosmoBolognaLib.Object_set_magnitude(self, *args)

    def set_richness(self, *args):
        return _CosmoBolognaLib.Object_set_richness(self, *args)

    def set_generic(self, *args):
        return _CosmoBolognaLib.Object_set_generic(self, *args)

    def set_radius(self, *args):
        return _CosmoBolognaLib.Object_set_radius(self, *args)
Object_swigregister = _CosmoBolognaLib.Object_swigregister
Object_swigregister(Object)

def Object_Create(*args):
    return _CosmoBolognaLib.Object_Create(*args)
Object_Create = _CosmoBolognaLib.Object_Create

class RandomObject(Object):
    __swig_setmethods__ = {}
    for _s in [Object]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RandomObject, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RandomObject, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_RandomObject(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_RandomObject
    __del__ = lambda self: None
RandomObject_swigregister = _CosmoBolognaLib.RandomObject_swigregister
RandomObject_swigregister(RandomObject)

class Halo(Object):
    __swig_setmethods__ = {}
    for _s in [Object]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Halo, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Halo, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Halo(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Halo
    __del__ = lambda self: None

    def vx(self):
        return _CosmoBolognaLib.Halo_vx(self)

    def vy(self):
        return _CosmoBolognaLib.Halo_vy(self)

    def vz(self):
        return _CosmoBolognaLib.Halo_vz(self)

    def mass(self):
        return _CosmoBolognaLib.Halo_mass(self)

    def set_vx(self, *args):
        return _CosmoBolognaLib.Halo_set_vx(self, *args)

    def set_vy(self, *args):
        return _CosmoBolognaLib.Halo_set_vy(self, *args)

    def set_vz(self, *args):
        return _CosmoBolognaLib.Halo_set_vz(self, *args)

    def set_mass(self, *args):
        return _CosmoBolognaLib.Halo_set_mass(self, *args)
Halo_swigregister = _CosmoBolognaLib.Halo_swigregister
Halo_swigregister(Halo)

class Mock(Halo):
    __swig_setmethods__ = {}
    for _s in [Halo]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Mock, name, value)
    __swig_getmethods__ = {}
    for _s in [Halo]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Mock, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Mock(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Mock
    __del__ = lambda self: None

    def generic(self):
        return _CosmoBolognaLib.Mock_generic(self)

    def set_generic(self, *args):
        return _CosmoBolognaLib.Mock_set_generic(self, *args)
Mock_swigregister = _CosmoBolognaLib.Mock_swigregister
Mock_swigregister(Mock)

class Galaxy(Object):
    __swig_setmethods__ = {}
    for _s in [Object]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Galaxy, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Galaxy, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Galaxy(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Galaxy
    __del__ = lambda self: None

    def mass(self):
        return _CosmoBolognaLib.Galaxy_mass(self)

    def magnitude(self):
        return _CosmoBolognaLib.Galaxy_magnitude(self)

    def set_mass(self, *args):
        return _CosmoBolognaLib.Galaxy_set_mass(self, *args)

    def set_magnitude(self, *args):
        return _CosmoBolognaLib.Galaxy_set_magnitude(self, *args)
Galaxy_swigregister = _CosmoBolognaLib.Galaxy_swigregister
Galaxy_swigregister(Galaxy)

class Cluster(Object):
    __swig_setmethods__ = {}
    for _s in [Object]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Cluster, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Cluster, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Cluster(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Cluster
    __del__ = lambda self: None

    def mass(self):
        return _CosmoBolognaLib.Cluster_mass(self)

    def richness(self):
        return _CosmoBolognaLib.Cluster_richness(self)

    def set_mass(self, *args):
        return _CosmoBolognaLib.Cluster_set_mass(self, *args)

    def set_richness(self, *args):
        return _CosmoBolognaLib.Cluster_set_richness(self, *args)
Cluster_swigregister = _CosmoBolognaLib.Cluster_swigregister
Cluster_swigregister(Cluster)


_CosmoBolognaLib._X__swigconstant(_CosmoBolognaLib)
_X_ = _CosmoBolognaLib._X_

_CosmoBolognaLib._Y__swigconstant(_CosmoBolognaLib)
_Y_ = _CosmoBolognaLib._Y_

_CosmoBolognaLib._Z__swigconstant(_CosmoBolognaLib)
_Z_ = _CosmoBolognaLib._Z_

_CosmoBolognaLib._RA__swigconstant(_CosmoBolognaLib)
_RA_ = _CosmoBolognaLib._RA_

_CosmoBolognaLib._Dec__swigconstant(_CosmoBolognaLib)
_Dec_ = _CosmoBolognaLib._Dec_

_CosmoBolognaLib._Redshift__swigconstant(_CosmoBolognaLib)
_Redshift_ = _CosmoBolognaLib._Redshift_

_CosmoBolognaLib._Dc__swigconstant(_CosmoBolognaLib)
_Dc_ = _CosmoBolognaLib._Dc_

_CosmoBolognaLib._Weight__swigconstant(_CosmoBolognaLib)
_Weight_ = _CosmoBolognaLib._Weight_

_CosmoBolognaLib._Mass__swigconstant(_CosmoBolognaLib)
_Mass_ = _CosmoBolognaLib._Mass_

_CosmoBolognaLib._Richness__swigconstant(_CosmoBolognaLib)
_Richness_ = _CosmoBolognaLib._Richness_

_CosmoBolognaLib._Magnitude__swigconstant(_CosmoBolognaLib)
_Magnitude_ = _CosmoBolognaLib._Magnitude_

_CosmoBolognaLib._Vx__swigconstant(_CosmoBolognaLib)
_Vx_ = _CosmoBolognaLib._Vx_

_CosmoBolognaLib._Vy__swigconstant(_CosmoBolognaLib)
_Vy_ = _CosmoBolognaLib._Vy_

_CosmoBolognaLib._Vz__swigconstant(_CosmoBolognaLib)
_Vz_ = _CosmoBolognaLib._Vz_

_CosmoBolognaLib._Region__swigconstant(_CosmoBolognaLib)
_Region_ = _CosmoBolognaLib._Region_

_CosmoBolognaLib._Radius__swigconstant(_CosmoBolognaLib)
_Radius_ = _CosmoBolognaLib._Radius_

_CosmoBolognaLib._X_displacement__swigconstant(_CosmoBolognaLib)
_X_displacement_ = _CosmoBolognaLib._X_displacement_

_CosmoBolognaLib._Y_displacement__swigconstant(_CosmoBolognaLib)
_Y_displacement_ = _CosmoBolognaLib._Y_displacement_

_CosmoBolognaLib._Z_displacement__swigconstant(_CosmoBolognaLib)
_Z_displacement_ = _CosmoBolognaLib._Z_displacement_

_CosmoBolognaLib._Generic__swigconstant(_CosmoBolognaLib)
_Generic_ = _CosmoBolognaLib._Generic_

_CosmoBolognaLib._createRandom_box__swigconstant(_CosmoBolognaLib)
_createRandom_box_ = _CosmoBolognaLib._createRandom_box_

_CosmoBolognaLib._createRandom_square__swigconstant(_CosmoBolognaLib)
_createRandom_square_ = _CosmoBolognaLib._createRandom_square_

_CosmoBolognaLib._createRandom_shuffle__swigconstant(_CosmoBolognaLib)
_createRandom_shuffle_ = _CosmoBolognaLib._createRandom_shuffle_

_CosmoBolognaLib._createRandom_cone__swigconstant(_CosmoBolognaLib)
_createRandom_cone_ = _CosmoBolognaLib._createRandom_cone_

_CosmoBolognaLib._createRandom_MANGLE__swigconstant(_CosmoBolognaLib)
_createRandom_MANGLE_ = _CosmoBolognaLib._createRandom_MANGLE_

_CosmoBolognaLib._createRandom_VIPERS__swigconstant(_CosmoBolognaLib)
_createRandom_VIPERS_ = _CosmoBolognaLib._createRandom_VIPERS_
class Catalogue(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Catalogue, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Catalogue, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_Catalogue
    __del__ = lambda self: None

    def sample(self):
        return _CosmoBolognaLib.Catalogue_sample(self)

    def index(self):
        return _CosmoBolognaLib.Catalogue_index(self)

    def xx(self, i):
        return _CosmoBolognaLib.Catalogue_xx(self, i)

    def yy(self, i):
        return _CosmoBolognaLib.Catalogue_yy(self, i)

    def zz(self, i):
        return _CosmoBolognaLib.Catalogue_zz(self, i)

    def vx(self, i):
        return _CosmoBolognaLib.Catalogue_vx(self, i)

    def vy(self, i):
        return _CosmoBolognaLib.Catalogue_vy(self, i)

    def vz(self, i):
        return _CosmoBolognaLib.Catalogue_vz(self, i)

    def dc(self, i):
        return _CosmoBolognaLib.Catalogue_dc(self, i)

    def ra(self, i):
        return _CosmoBolognaLib.Catalogue_ra(self, i)

    def dec(self, i):
        return _CosmoBolognaLib.Catalogue_dec(self, i)

    def redshift(self, i):
        return _CosmoBolognaLib.Catalogue_redshift(self, i)

    def weight(self, i):
        return _CosmoBolognaLib.Catalogue_weight(self, i)

    def x_displacement(self, i):
        return _CosmoBolognaLib.Catalogue_x_displacement(self, i)

    def y_displacement(self, i):
        return _CosmoBolognaLib.Catalogue_y_displacement(self, i)

    def z_displacement(self, i):
        return _CosmoBolognaLib.Catalogue_z_displacement(self, i)

    def region_list(self):
        return _CosmoBolognaLib.Catalogue_region_list(self)

    def nRegions(self):
        return _CosmoBolognaLib.Catalogue_nRegions(self)

    def field_list(self):
        return _CosmoBolognaLib.Catalogue_field_list(self)

    def nFields(self):
        return _CosmoBolognaLib.Catalogue_nFields(self)

    def mass(self, i):
        return _CosmoBolognaLib.Catalogue_mass(self, i)

    def magnitude(self, i):
        return _CosmoBolognaLib.Catalogue_magnitude(self, i)

    def radius(self, i):
        return _CosmoBolognaLib.Catalogue_radius(self, i)

    def richness(self, i):
        return _CosmoBolognaLib.Catalogue_richness(self, i)

    def generic(self, i):
        return _CosmoBolognaLib.Catalogue_generic(self, i)

    def region(self, *args):
        return _CosmoBolognaLib.Catalogue_region(self, *args)

    def field(self, *args):
        return _CosmoBolognaLib.Catalogue_field(self, *args)

    def var(self, arg2):
        return _CosmoBolognaLib.Catalogue_var(self, arg2)

    def catalogue_object(self, *args):
        return _CosmoBolognaLib.Catalogue_catalogue_object(self, *args)

    def coordinate(self, i):
        return _CosmoBolognaLib.Catalogue_coordinate(self, i)

    def nObjects(self):
        return _CosmoBolognaLib.Catalogue_nObjects(self)

    def Min(self, var_name):
        return _CosmoBolognaLib.Catalogue_Min(self, var_name)

    def Max(self, var_name):
        return _CosmoBolognaLib.Catalogue_Max(self, var_name)

    def stats_var(self, *args):
        return _CosmoBolognaLib.Catalogue_stats_var(self, *args)

    def var_distr(self, *args):
        return _CosmoBolognaLib.Catalogue_var_distr(self, *args)

    def weightedN(self):
        return _CosmoBolognaLib.Catalogue_weightedN(self)

    def set_region(self, region):
        return _CosmoBolognaLib.Catalogue_set_region(self, region)

    def set_field(self, field):
        return _CosmoBolognaLib.Catalogue_set_field(self, field)

    def set_var(self, var_name, var):
        return _CosmoBolognaLib.Catalogue_set_var(self, var_name, var)

    def remove_objects(self):
        return _CosmoBolognaLib.Catalogue_remove_objects(self)

    def remove_object(self, index):
        return _CosmoBolognaLib.Catalogue_remove_object(self, index)

    def computeComovingCoordinates(self, *args):
        return _CosmoBolognaLib.Catalogue_computeComovingCoordinates(self, *args)

    def computePolarCoordinates(self, *args):
        return _CosmoBolognaLib.Catalogue_computePolarCoordinates(self, *args)

    def normalizeComovingCoordinates(self):
        return _CosmoBolognaLib.Catalogue_normalizeComovingCoordinates(self)

    def restoreComovingCoordinates(self):
        return _CosmoBolognaLib.Catalogue_restoreComovingCoordinates(self)

    def Order(self, *args):
        return _CosmoBolognaLib.Catalogue_Order(self, *args)

    def write_comoving_coordinates(self, outputFile):
        return _CosmoBolognaLib.Catalogue_write_comoving_coordinates(self, outputFile)

    def write_obs_coordinates(self, outputFile):
        return _CosmoBolognaLib.Catalogue_write_obs_coordinates(self, outputFile)

    def write_data(self, outputFile):
        return _CosmoBolognaLib.Catalogue_write_data(self, outputFile)

    def distance(self, i, obj):
        return _CosmoBolognaLib.Catalogue_distance(self, i, obj)

    def angsep_xyz(self, i, obj):
        return _CosmoBolognaLib.Catalogue_angsep_xyz(self, i, obj)

    def __iadd__(self, *args):
        return _CosmoBolognaLib.Catalogue___iadd__(self, *args)

    def cut(self, arg2, arg3, arg4, excl=0):
        return _CosmoBolognaLib.Catalogue_cut(self, arg2, arg3, arg4, excl)

    def smooth(self, *args):
        return _CosmoBolognaLib.Catalogue_smooth(self, *args)

    def nObjects_condition(self, arg2, arg3, arg4, excl=0):
        return _CosmoBolognaLib.Catalogue_nObjects_condition(self, arg2, arg3, arg4, excl)

    def weightedN_condition(self, arg2, arg3, arg4, excl=0):
        return _CosmoBolognaLib.Catalogue_weightedN_condition(self, arg2, arg3, arg4, excl)

    def density_field(self, *args):
        return _CosmoBolognaLib.Catalogue_density_field(self, *args)

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Catalogue(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_object(self, *args):
        return _CosmoBolognaLib.Catalogue_add_object(self, *args)

    def add_objects(self, *args):
        return _CosmoBolognaLib.Catalogue_add_objects(self, *args)

    def replace_objects(self, *args):
        return _CosmoBolognaLib.Catalogue_replace_objects(self, *args)
Catalogue_swigregister = _CosmoBolognaLib.Catalogue_swigregister
Catalogue_swigregister(Catalogue)

class ChainMesh_Catalogue(ChainMesh):
    __swig_setmethods__ = {}
    for _s in [ChainMesh]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChainMesh_Catalogue, name, value)
    __swig_getmethods__ = {}
    for _s in [ChainMesh]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChainMesh_Catalogue, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_ChainMesh_Catalogue
    __del__ = lambda self: None

    def set_par(self, cell_size, cat, rmax):
        return _CosmoBolognaLib.ChainMesh_Catalogue_set_par(self, cell_size, cat, rmax)

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_ChainMesh_Catalogue(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_order(self, order):
        return _CosmoBolognaLib.ChainMesh_Catalogue_get_order(self, order)

    def object_list(self, object, ii=-1):
        return _CosmoBolognaLib.ChainMesh_Catalogue_object_list(self, object, ii)

    def catalogue(self):
        return _CosmoBolognaLib.ChainMesh_Catalogue_catalogue(self)
ChainMesh_Catalogue_swigregister = _CosmoBolognaLib.ChainMesh_Catalogue_swigregister
ChainMesh_Catalogue_swigregister(ChainMesh_Catalogue)

class Void(Object):
    __swig_setmethods__ = {}
    for _s in [Object]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Void, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Void, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Void(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Void
    __del__ = lambda self: None

    def radius(self):
        return _CosmoBolognaLib.Void_radius(self)

    def volNorm(self):
        return _CosmoBolognaLib.Void_volNorm(self)

    def volume(self):
        return _CosmoBolognaLib.Void_volume(self)

    def ID(self):
        return _CosmoBolognaLib.Void_ID(self)

    def densContr(self):
        return _CosmoBolognaLib.Void_densContr(self)

    def parentID(self):
        return _CosmoBolognaLib.Void_parentID(self)

    def treeLevel(self):
        return _CosmoBolognaLib.Void_treeLevel(self)

    def child(self):
        return _CosmoBolognaLib.Void_child(self)

    def rho0(self):
        return _CosmoBolognaLib.Void_rho0(self)

    def rho0Norm(self):
        return _CosmoBolognaLib.Void_rho0Norm(self)

    def set_radius(self, *args):
        return _CosmoBolognaLib.Void_set_radius(self, *args)

    def set_volNorm(self, *args):
        return _CosmoBolognaLib.Void_set_volNorm(self, *args)

    def set_volume(self, *args):
        return _CosmoBolognaLib.Void_set_volume(self, *args)

    def set_ID(self, *args):
        return _CosmoBolognaLib.Void_set_ID(self, *args)

    def set_densContr(self, *args):
        return _CosmoBolognaLib.Void_set_densContr(self, *args)

    def set_parentID(self, *args):
        return _CosmoBolognaLib.Void_set_parentID(self, *args)

    def set_treeLevel(self, *args):
        return _CosmoBolognaLib.Void_set_treeLevel(self, *args)

    def set_child(self, *args):
        return _CosmoBolognaLib.Void_set_child(self, *args)

    def set_rho0(self, *args):
        return _CosmoBolognaLib.Void_set_rho0(self, *args)

    def set_rho0Norm(self, *args):
        return _CosmoBolognaLib.Void_set_rho0Norm(self, *args)
Void_swigregister = _CosmoBolognaLib.Void_swigregister
Void_swigregister(Void)

class RandomObjVec(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RandomObjVec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RandomObjVec, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CosmoBolognaLib.RandomObjVec_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CosmoBolognaLib.RandomObjVec___nonzero__(self)

    def __bool__(self):
        return _CosmoBolognaLib.RandomObjVec___bool__(self)

    def __len__(self):
        return _CosmoBolognaLib.RandomObjVec___len__(self)

    def pop(self):
        return _CosmoBolognaLib.RandomObjVec_pop(self)

    def __getslice__(self, i, j):
        return _CosmoBolognaLib.RandomObjVec___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _CosmoBolognaLib.RandomObjVec___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _CosmoBolognaLib.RandomObjVec___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _CosmoBolognaLib.RandomObjVec___delitem__(self, *args)

    def __getitem__(self, *args):
        return _CosmoBolognaLib.RandomObjVec___getitem__(self, *args)

    def __setitem__(self, *args):
        return _CosmoBolognaLib.RandomObjVec___setitem__(self, *args)

    def append(self, x):
        return _CosmoBolognaLib.RandomObjVec_append(self, x)

    def empty(self):
        return _CosmoBolognaLib.RandomObjVec_empty(self)

    def size(self):
        return _CosmoBolognaLib.RandomObjVec_size(self)

    def clear(self):
        return _CosmoBolognaLib.RandomObjVec_clear(self)

    def swap(self, v):
        return _CosmoBolognaLib.RandomObjVec_swap(self, v)

    def get_allocator(self):
        return _CosmoBolognaLib.RandomObjVec_get_allocator(self)

    def begin(self):
        return _CosmoBolognaLib.RandomObjVec_begin(self)

    def end(self):
        return _CosmoBolognaLib.RandomObjVec_end(self)

    def rbegin(self):
        return _CosmoBolognaLib.RandomObjVec_rbegin(self)

    def rend(self):
        return _CosmoBolognaLib.RandomObjVec_rend(self)

    def pop_back(self):
        return _CosmoBolognaLib.RandomObjVec_pop_back(self)

    def erase(self, *args):
        return _CosmoBolognaLib.RandomObjVec_erase(self, *args)

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_RandomObjVec(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _CosmoBolognaLib.RandomObjVec_push_back(self, x)

    def front(self):
        return _CosmoBolognaLib.RandomObjVec_front(self)

    def back(self):
        return _CosmoBolognaLib.RandomObjVec_back(self)

    def assign(self, n, x):
        return _CosmoBolognaLib.RandomObjVec_assign(self, n, x)

    def resize(self, *args):
        return _CosmoBolognaLib.RandomObjVec_resize(self, *args)

    def insert(self, *args):
        return _CosmoBolognaLib.RandomObjVec_insert(self, *args)

    def reserve(self, n):
        return _CosmoBolognaLib.RandomObjVec_reserve(self, n)

    def capacity(self):
        return _CosmoBolognaLib.RandomObjVec_capacity(self)
    __swig_destroy__ = _CosmoBolognaLib.delete_RandomObjVec
    __del__ = lambda self: None
RandomObjVec_swigregister = _CosmoBolognaLib.RandomObjVec_swigregister
RandomObjVec_swigregister(RandomObjVec)

class MockVec(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MockVec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MockVec, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CosmoBolognaLib.MockVec_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CosmoBolognaLib.MockVec___nonzero__(self)

    def __bool__(self):
        return _CosmoBolognaLib.MockVec___bool__(self)

    def __len__(self):
        return _CosmoBolognaLib.MockVec___len__(self)

    def pop(self):
        return _CosmoBolognaLib.MockVec_pop(self)

    def __getslice__(self, i, j):
        return _CosmoBolognaLib.MockVec___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _CosmoBolognaLib.MockVec___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _CosmoBolognaLib.MockVec___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _CosmoBolognaLib.MockVec___delitem__(self, *args)

    def __getitem__(self, *args):
        return _CosmoBolognaLib.MockVec___getitem__(self, *args)

    def __setitem__(self, *args):
        return _CosmoBolognaLib.MockVec___setitem__(self, *args)

    def append(self, x):
        return _CosmoBolognaLib.MockVec_append(self, x)

    def empty(self):
        return _CosmoBolognaLib.MockVec_empty(self)

    def size(self):
        return _CosmoBolognaLib.MockVec_size(self)

    def clear(self):
        return _CosmoBolognaLib.MockVec_clear(self)

    def swap(self, v):
        return _CosmoBolognaLib.MockVec_swap(self, v)

    def get_allocator(self):
        return _CosmoBolognaLib.MockVec_get_allocator(self)

    def begin(self):
        return _CosmoBolognaLib.MockVec_begin(self)

    def end(self):
        return _CosmoBolognaLib.MockVec_end(self)

    def rbegin(self):
        return _CosmoBolognaLib.MockVec_rbegin(self)

    def rend(self):
        return _CosmoBolognaLib.MockVec_rend(self)

    def pop_back(self):
        return _CosmoBolognaLib.MockVec_pop_back(self)

    def erase(self, *args):
        return _CosmoBolognaLib.MockVec_erase(self, *args)

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_MockVec(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _CosmoBolognaLib.MockVec_push_back(self, x)

    def front(self):
        return _CosmoBolognaLib.MockVec_front(self)

    def back(self):
        return _CosmoBolognaLib.MockVec_back(self)

    def assign(self, n, x):
        return _CosmoBolognaLib.MockVec_assign(self, n, x)

    def resize(self, *args):
        return _CosmoBolognaLib.MockVec_resize(self, *args)

    def insert(self, *args):
        return _CosmoBolognaLib.MockVec_insert(self, *args)

    def reserve(self, n):
        return _CosmoBolognaLib.MockVec_reserve(self, n)

    def capacity(self):
        return _CosmoBolognaLib.MockVec_capacity(self)
    __swig_destroy__ = _CosmoBolognaLib.delete_MockVec
    __del__ = lambda self: None
MockVec_swigregister = _CosmoBolognaLib.MockVec_swigregister
MockVec_swigregister(MockVec)

class HaloVec(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HaloVec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HaloVec, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CosmoBolognaLib.HaloVec_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CosmoBolognaLib.HaloVec___nonzero__(self)

    def __bool__(self):
        return _CosmoBolognaLib.HaloVec___bool__(self)

    def __len__(self):
        return _CosmoBolognaLib.HaloVec___len__(self)

    def pop(self):
        return _CosmoBolognaLib.HaloVec_pop(self)

    def __getslice__(self, i, j):
        return _CosmoBolognaLib.HaloVec___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _CosmoBolognaLib.HaloVec___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _CosmoBolognaLib.HaloVec___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _CosmoBolognaLib.HaloVec___delitem__(self, *args)

    def __getitem__(self, *args):
        return _CosmoBolognaLib.HaloVec___getitem__(self, *args)

    def __setitem__(self, *args):
        return _CosmoBolognaLib.HaloVec___setitem__(self, *args)

    def append(self, x):
        return _CosmoBolognaLib.HaloVec_append(self, x)

    def empty(self):
        return _CosmoBolognaLib.HaloVec_empty(self)

    def size(self):
        return _CosmoBolognaLib.HaloVec_size(self)

    def clear(self):
        return _CosmoBolognaLib.HaloVec_clear(self)

    def swap(self, v):
        return _CosmoBolognaLib.HaloVec_swap(self, v)

    def get_allocator(self):
        return _CosmoBolognaLib.HaloVec_get_allocator(self)

    def begin(self):
        return _CosmoBolognaLib.HaloVec_begin(self)

    def end(self):
        return _CosmoBolognaLib.HaloVec_end(self)

    def rbegin(self):
        return _CosmoBolognaLib.HaloVec_rbegin(self)

    def rend(self):
        return _CosmoBolognaLib.HaloVec_rend(self)

    def pop_back(self):
        return _CosmoBolognaLib.HaloVec_pop_back(self)

    def erase(self, *args):
        return _CosmoBolognaLib.HaloVec_erase(self, *args)

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_HaloVec(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _CosmoBolognaLib.HaloVec_push_back(self, x)

    def front(self):
        return _CosmoBolognaLib.HaloVec_front(self)

    def back(self):
        return _CosmoBolognaLib.HaloVec_back(self)

    def assign(self, n, x):
        return _CosmoBolognaLib.HaloVec_assign(self, n, x)

    def resize(self, *args):
        return _CosmoBolognaLib.HaloVec_resize(self, *args)

    def insert(self, *args):
        return _CosmoBolognaLib.HaloVec_insert(self, *args)

    def reserve(self, n):
        return _CosmoBolognaLib.HaloVec_reserve(self, n)

    def capacity(self):
        return _CosmoBolognaLib.HaloVec_capacity(self)
    __swig_destroy__ = _CosmoBolognaLib.delete_HaloVec
    __del__ = lambda self: None
HaloVec_swigregister = _CosmoBolognaLib.HaloVec_swigregister
HaloVec_swigregister(HaloVec)

class GalaxyVec(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GalaxyVec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GalaxyVec, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CosmoBolognaLib.GalaxyVec_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CosmoBolognaLib.GalaxyVec___nonzero__(self)

    def __bool__(self):
        return _CosmoBolognaLib.GalaxyVec___bool__(self)

    def __len__(self):
        return _CosmoBolognaLib.GalaxyVec___len__(self)

    def pop(self):
        return _CosmoBolognaLib.GalaxyVec_pop(self)

    def __getslice__(self, i, j):
        return _CosmoBolognaLib.GalaxyVec___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _CosmoBolognaLib.GalaxyVec___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _CosmoBolognaLib.GalaxyVec___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _CosmoBolognaLib.GalaxyVec___delitem__(self, *args)

    def __getitem__(self, *args):
        return _CosmoBolognaLib.GalaxyVec___getitem__(self, *args)

    def __setitem__(self, *args):
        return _CosmoBolognaLib.GalaxyVec___setitem__(self, *args)

    def append(self, x):
        return _CosmoBolognaLib.GalaxyVec_append(self, x)

    def empty(self):
        return _CosmoBolognaLib.GalaxyVec_empty(self)

    def size(self):
        return _CosmoBolognaLib.GalaxyVec_size(self)

    def clear(self):
        return _CosmoBolognaLib.GalaxyVec_clear(self)

    def swap(self, v):
        return _CosmoBolognaLib.GalaxyVec_swap(self, v)

    def get_allocator(self):
        return _CosmoBolognaLib.GalaxyVec_get_allocator(self)

    def begin(self):
        return _CosmoBolognaLib.GalaxyVec_begin(self)

    def end(self):
        return _CosmoBolognaLib.GalaxyVec_end(self)

    def rbegin(self):
        return _CosmoBolognaLib.GalaxyVec_rbegin(self)

    def rend(self):
        return _CosmoBolognaLib.GalaxyVec_rend(self)

    def pop_back(self):
        return _CosmoBolognaLib.GalaxyVec_pop_back(self)

    def erase(self, *args):
        return _CosmoBolognaLib.GalaxyVec_erase(self, *args)

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_GalaxyVec(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _CosmoBolognaLib.GalaxyVec_push_back(self, x)

    def front(self):
        return _CosmoBolognaLib.GalaxyVec_front(self)

    def back(self):
        return _CosmoBolognaLib.GalaxyVec_back(self)

    def assign(self, n, x):
        return _CosmoBolognaLib.GalaxyVec_assign(self, n, x)

    def resize(self, *args):
        return _CosmoBolognaLib.GalaxyVec_resize(self, *args)

    def insert(self, *args):
        return _CosmoBolognaLib.GalaxyVec_insert(self, *args)

    def reserve(self, n):
        return _CosmoBolognaLib.GalaxyVec_reserve(self, n)

    def capacity(self):
        return _CosmoBolognaLib.GalaxyVec_capacity(self)
    __swig_destroy__ = _CosmoBolognaLib.delete_GalaxyVec
    __del__ = lambda self: None
GalaxyVec_swigregister = _CosmoBolognaLib.GalaxyVec_swigregister
GalaxyVec_swigregister(GalaxyVec)

class ClusterVec(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ClusterVec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ClusterVec, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CosmoBolognaLib.ClusterVec_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CosmoBolognaLib.ClusterVec___nonzero__(self)

    def __bool__(self):
        return _CosmoBolognaLib.ClusterVec___bool__(self)

    def __len__(self):
        return _CosmoBolognaLib.ClusterVec___len__(self)

    def pop(self):
        return _CosmoBolognaLib.ClusterVec_pop(self)

    def __getslice__(self, i, j):
        return _CosmoBolognaLib.ClusterVec___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _CosmoBolognaLib.ClusterVec___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _CosmoBolognaLib.ClusterVec___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _CosmoBolognaLib.ClusterVec___delitem__(self, *args)

    def __getitem__(self, *args):
        return _CosmoBolognaLib.ClusterVec___getitem__(self, *args)

    def __setitem__(self, *args):
        return _CosmoBolognaLib.ClusterVec___setitem__(self, *args)

    def append(self, x):
        return _CosmoBolognaLib.ClusterVec_append(self, x)

    def empty(self):
        return _CosmoBolognaLib.ClusterVec_empty(self)

    def size(self):
        return _CosmoBolognaLib.ClusterVec_size(self)

    def clear(self):
        return _CosmoBolognaLib.ClusterVec_clear(self)

    def swap(self, v):
        return _CosmoBolognaLib.ClusterVec_swap(self, v)

    def get_allocator(self):
        return _CosmoBolognaLib.ClusterVec_get_allocator(self)

    def begin(self):
        return _CosmoBolognaLib.ClusterVec_begin(self)

    def end(self):
        return _CosmoBolognaLib.ClusterVec_end(self)

    def rbegin(self):
        return _CosmoBolognaLib.ClusterVec_rbegin(self)

    def rend(self):
        return _CosmoBolognaLib.ClusterVec_rend(self)

    def pop_back(self):
        return _CosmoBolognaLib.ClusterVec_pop_back(self)

    def erase(self, *args):
        return _CosmoBolognaLib.ClusterVec_erase(self, *args)

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_ClusterVec(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _CosmoBolognaLib.ClusterVec_push_back(self, x)

    def front(self):
        return _CosmoBolognaLib.ClusterVec_front(self)

    def back(self):
        return _CosmoBolognaLib.ClusterVec_back(self)

    def assign(self, n, x):
        return _CosmoBolognaLib.ClusterVec_assign(self, n, x)

    def resize(self, *args):
        return _CosmoBolognaLib.ClusterVec_resize(self, *args)

    def insert(self, *args):
        return _CosmoBolognaLib.ClusterVec_insert(self, *args)

    def reserve(self, n):
        return _CosmoBolognaLib.ClusterVec_reserve(self, n)

    def capacity(self):
        return _CosmoBolognaLib.ClusterVec_capacity(self)
    __swig_destroy__ = _CosmoBolognaLib.delete_ClusterVec
    __del__ = lambda self: None
ClusterVec_swigregister = _CosmoBolognaLib.ClusterVec_swigregister
ClusterVec_swigregister(ClusterVec)

class ObjectPtr(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ObjectPtr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ObjectPtr, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _CosmoBolognaLib.new_ObjectPtr()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_ObjectPtr
    __del__ = lambda self: None
ObjectPtr_swigregister = _CosmoBolognaLib.ObjectPtr_swigregister
ObjectPtr_swigregister(ObjectPtr)

class VoidPtr(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VoidPtr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VoidPtr, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _CosmoBolognaLib.new_VoidPtr()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_VoidPtr
    __del__ = lambda self: None
VoidPtr_swigregister = _CosmoBolognaLib.VoidPtr_swigregister
VoidPtr_swigregister(VoidPtr)

class Catalogueptr(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Catalogueptr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Catalogueptr, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _CosmoBolognaLib.new_Catalogueptr()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Catalogueptr
    __del__ = lambda self: None
Catalogueptr_swigregister = _CosmoBolognaLib.Catalogueptr_swigregister
Catalogueptr_swigregister(Catalogueptr)

class LogNormal(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LogNormal, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LogNormal, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_LogNormal
    __del__ = lambda self: None

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_LogNormal(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setCatalogues(self, data, random):
        return _CosmoBolognaLib.LogNormal_setCatalogues(self, data, random)

    def setParameters_from_xi(self, rr, xi):
        return _CosmoBolognaLib.LogNormal_setParameters_from_xi(self, rr, xi)

    def setParameters_from_model(self, *args):
        return _CosmoBolognaLib.LogNormal_setParameters_from_model(self, *args)

    def set_nLN(self, nLN):
        return _CosmoBolognaLib.LogNormal_set_nLN(self, nLN)

    def nLN(self):
        return _CosmoBolognaLib.LogNormal_nLN(self)

    def LNCat(self, i):
        return _CosmoBolognaLib.LogNormal_LNCat(self, i)

    def generate_LogNormal_mock(self, *args):
        return _CosmoBolognaLib.LogNormal_generate_LogNormal_mock(self, *args)
LogNormal_swigregister = _CosmoBolognaLib.LogNormal_swigregister
LogNormal_swigregister(LogNormal)


_CosmoBolognaLib._angular_lin__swigconstant(_CosmoBolognaLib)
_angular_lin_ = _CosmoBolognaLib._angular_lin_

_CosmoBolognaLib._angular_log__swigconstant(_CosmoBolognaLib)
_angular_log_ = _CosmoBolognaLib._angular_log_

_CosmoBolognaLib._comoving_lin__swigconstant(_CosmoBolognaLib)
_comoving_lin_ = _CosmoBolognaLib._comoving_lin_

_CosmoBolognaLib._comoving_log__swigconstant(_CosmoBolognaLib)
_comoving_log_ = _CosmoBolognaLib._comoving_log_

_CosmoBolognaLib._comovingCartesian_linlin__swigconstant(_CosmoBolognaLib)
_comovingCartesian_linlin_ = _CosmoBolognaLib._comovingCartesian_linlin_

_CosmoBolognaLib._comovingCartesian_linlog__swigconstant(_CosmoBolognaLib)
_comovingCartesian_linlog_ = _CosmoBolognaLib._comovingCartesian_linlog_

_CosmoBolognaLib._comovingCartesian_loglin__swigconstant(_CosmoBolognaLib)
_comovingCartesian_loglin_ = _CosmoBolognaLib._comovingCartesian_loglin_

_CosmoBolognaLib._comovingCartesian_loglog__swigconstant(_CosmoBolognaLib)
_comovingCartesian_loglog_ = _CosmoBolognaLib._comovingCartesian_loglog_

_CosmoBolognaLib._comovingPolar_linlin__swigconstant(_CosmoBolognaLib)
_comovingPolar_linlin_ = _CosmoBolognaLib._comovingPolar_linlin_

_CosmoBolognaLib._comovingPolar_linlog__swigconstant(_CosmoBolognaLib)
_comovingPolar_linlog_ = _CosmoBolognaLib._comovingPolar_linlog_

_CosmoBolognaLib._comovingPolar_loglin__swigconstant(_CosmoBolognaLib)
_comovingPolar_loglin_ = _CosmoBolognaLib._comovingPolar_loglin_

_CosmoBolognaLib._comovingPolar_loglog__swigconstant(_CosmoBolognaLib)
_comovingPolar_loglog_ = _CosmoBolognaLib._comovingPolar_loglog_

_CosmoBolognaLib._standard__swigconstant(_CosmoBolognaLib)
_standard_ = _CosmoBolognaLib._standard_

_CosmoBolognaLib._extra__swigconstant(_CosmoBolognaLib)
_extra_ = _CosmoBolognaLib._extra_
class Pair(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Pair, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair
    __del__ = lambda self: None
    __swig_getmethods__["Create"] = lambda x: _CosmoBolognaLib.Pair_Create
    if _newclass:
        Create = staticmethod(_CosmoBolognaLib.Pair_Create)

    def pairDim(self):
        return _CosmoBolognaLib.Pair_pairDim(self)

    def pairType(self):
        return _CosmoBolognaLib.Pair_pairType(self)

    def pairInfo(self):
        return _CosmoBolognaLib.Pair_pairInfo(self)

    def angularUnits(self):
        return _CosmoBolognaLib.Pair_angularUnits(self)

    def angularWeight(self):
        return _CosmoBolognaLib.Pair_angularWeight(self)

    def scale(self, *args):
        return _CosmoBolognaLib.Pair_scale(self, *args)

    def scale_mean(self, *args):
        return _CosmoBolognaLib.Pair_scale_mean(self, *args)

    def scale_sigma(self, *args):
        return _CosmoBolognaLib.Pair_scale_sigma(self, *args)

    def PP1D(self, *args):
        return _CosmoBolognaLib.Pair_PP1D(self, *args)

    def scale_D1(self, *args):
        return _CosmoBolognaLib.Pair_scale_D1(self, *args)

    def scale_D2(self, *args):
        return _CosmoBolognaLib.Pair_scale_D2(self, *args)

    def scale_D1_mean(self, *args):
        return _CosmoBolognaLib.Pair_scale_D1_mean(self, *args)

    def scale_D2_mean(self, *args):
        return _CosmoBolognaLib.Pair_scale_D2_mean(self, *args)

    def scale_D1_sigma(self, *args):
        return _CosmoBolognaLib.Pair_scale_D1_sigma(self, *args)

    def scale_D2_sigma(self, *args):
        return _CosmoBolognaLib.Pair_scale_D2_sigma(self, *args)

    def z_mean(self, *args):
        return _CosmoBolognaLib.Pair_z_mean(self, *args)

    def z_mean2D(self):
        return _CosmoBolognaLib.Pair_z_mean2D(self)

    def z_sigma(self, *args):
        return _CosmoBolognaLib.Pair_z_sigma(self, *args)

    def z_sigma2D(self):
        return _CosmoBolognaLib.Pair_z_sigma2D(self)

    def PP2D(self, *args):
        return _CosmoBolognaLib.Pair_PP2D(self, *args)

    def binSize_inv(self):
        return _CosmoBolognaLib.Pair_binSize_inv(self)

    def nbins(self):
        return _CosmoBolognaLib.Pair_nbins(self)

    def shift(self):
        return _CosmoBolognaLib.Pair_shift(self)

    def binSize_inv_D1(self):
        return _CosmoBolognaLib.Pair_binSize_inv_D1(self)

    def nbins_D1(self):
        return _CosmoBolognaLib.Pair_nbins_D1(self)

    def shift_D1(self):
        return _CosmoBolognaLib.Pair_shift_D1(self)

    def binSize_inv_D2(self):
        return _CosmoBolognaLib.Pair_binSize_inv_D2(self)

    def nbins_D2(self):
        return _CosmoBolognaLib.Pair_nbins_D2(self)

    def shift_D2(self):
        return _CosmoBolognaLib.Pair_shift_D2(self)

    def sMin(self):
        return _CosmoBolognaLib.Pair_sMin(self)

    def sMax(self):
        return _CosmoBolognaLib.Pair_sMax(self)

    def sMin_D1(self):
        return _CosmoBolognaLib.Pair_sMin_D1(self)

    def sMax_D1(self):
        return _CosmoBolognaLib.Pair_sMax_D1(self)

    def sMin_D2(self):
        return _CosmoBolognaLib.Pair_sMin_D2(self)

    def sMax_D2(self):
        return _CosmoBolognaLib.Pair_sMax_D2(self)

    def set_PP1D(self, i, pp):
        return _CosmoBolognaLib.Pair_set_PP1D(self, i, pp)

    def set_PP2D(self, i, j, pp):
        return _CosmoBolognaLib.Pair_set_PP2D(self, i, j, pp)

    def add_data1D(self, *args):
        return _CosmoBolognaLib.Pair_add_data1D(self, *args)

    def add_data2D(self, *args):
        return _CosmoBolognaLib.Pair_add_data2D(self, *args)

    def put(self, obj1, obj2):
        return _CosmoBolognaLib.Pair_put(self, obj1, obj2)

    def Sum(self, pp, ww=1):
        return _CosmoBolognaLib.Pair_Sum(self, pp, ww)

    def finalise(self):
        return _CosmoBolognaLib.Pair_finalise(self)
Pair_swigregister = _CosmoBolognaLib.Pair_swigregister
Pair_swigregister(Pair)

def Pair_Create(*args):
    return _CosmoBolognaLib.Pair_Create(*args)
Pair_Create = _CosmoBolognaLib.Pair_Create

class Pair1D(Pair):
    __swig_setmethods__ = {}
    for _s in [Pair]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair1D, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair1D, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair1D
    __del__ = lambda self: None

    def scale(self, *args):
        return _CosmoBolognaLib.Pair1D_scale(self, *args)

    def PP1D(self, *args):
        return _CosmoBolognaLib.Pair1D_PP1D(self, *args)

    def binSize_inv(self):
        return _CosmoBolognaLib.Pair1D_binSize_inv(self)

    def nbins(self):
        return _CosmoBolognaLib.Pair1D_nbins(self)

    def shift(self):
        return _CosmoBolognaLib.Pair1D_shift(self)

    def set_scale(self, i, ss):
        return _CosmoBolognaLib.Pair1D_set_scale(self, i, ss)

    def set_PP1D(self, i, pp):
        return _CosmoBolognaLib.Pair1D_set_PP1D(self, i, pp)

    def add_data1D(self, *args):
        return _CosmoBolognaLib.Pair1D_add_data1D(self, *args)

    def Sum(self, pp, ww=1):
        return _CosmoBolognaLib.Pair1D_Sum(self, pp, ww)
Pair1D_swigregister = _CosmoBolognaLib.Pair1D_swigregister
Pair1D_swigregister(Pair1D)

class Pair1D_angular(Pair1D):
    __swig_setmethods__ = {}
    for _s in [Pair1D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair1D_angular, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair1D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair1D_angular, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair1D_angular
    __del__ = lambda self: None

    def sMin(self):
        return _CosmoBolognaLib.Pair1D_angular_sMin(self)

    def sMax(self):
        return _CosmoBolognaLib.Pair1D_angular_sMax(self)
Pair1D_angular_swigregister = _CosmoBolognaLib.Pair1D_angular_swigregister
Pair1D_angular_swigregister(Pair1D_angular)

class Pair1D_angular_lin(Pair1D_angular):
    __swig_setmethods__ = {}
    for _s in [Pair1D_angular]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair1D_angular_lin, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair1D_angular]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair1D_angular_lin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Pair1D_angular_lin(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair1D_angular_lin
    __del__ = lambda self: None

    def put(self, obj1, obj2):
        return _CosmoBolognaLib.Pair1D_angular_lin_put(self, obj1, obj2)
Pair1D_angular_lin_swigregister = _CosmoBolognaLib.Pair1D_angular_lin_swigregister
Pair1D_angular_lin_swigregister(Pair1D_angular_lin)

class Pair1D_angular_log(Pair1D_angular):
    __swig_setmethods__ = {}
    for _s in [Pair1D_angular]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair1D_angular_log, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair1D_angular]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair1D_angular_log, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Pair1D_angular_log(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair1D_angular_log
    __del__ = lambda self: None

    def put(self, obj1, obj2):
        return _CosmoBolognaLib.Pair1D_angular_log_put(self, obj1, obj2)
Pair1D_angular_log_swigregister = _CosmoBolognaLib.Pair1D_angular_log_swigregister
Pair1D_angular_log_swigregister(Pair1D_angular_log)

class Pair1D_comoving(Pair1D):
    __swig_setmethods__ = {}
    for _s in [Pair1D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair1D_comoving, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair1D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair1D_comoving, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair1D_comoving
    __del__ = lambda self: None

    def sMin(self):
        return _CosmoBolognaLib.Pair1D_comoving_sMin(self)

    def sMax(self):
        return _CosmoBolognaLib.Pair1D_comoving_sMax(self)
Pair1D_comoving_swigregister = _CosmoBolognaLib.Pair1D_comoving_swigregister
Pair1D_comoving_swigregister(Pair1D_comoving)

class Pair1D_comoving_lin(Pair1D_comoving):
    __swig_setmethods__ = {}
    for _s in [Pair1D_comoving]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair1D_comoving_lin, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair1D_comoving]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair1D_comoving_lin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Pair1D_comoving_lin(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair1D_comoving_lin
    __del__ = lambda self: None

    def put(self, obj1, obj2):
        return _CosmoBolognaLib.Pair1D_comoving_lin_put(self, obj1, obj2)
Pair1D_comoving_lin_swigregister = _CosmoBolognaLib.Pair1D_comoving_lin_swigregister
Pair1D_comoving_lin_swigregister(Pair1D_comoving_lin)

class Pair1D_comoving_log(Pair1D_comoving):
    __swig_setmethods__ = {}
    for _s in [Pair1D_comoving]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair1D_comoving_log, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair1D_comoving]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair1D_comoving_log, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Pair1D_comoving_log(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair1D_comoving_log
    __del__ = lambda self: None

    def put(self, obj1, obj2):
        return _CosmoBolognaLib.Pair1D_comoving_log_put(self, obj1, obj2)
Pair1D_comoving_log_swigregister = _CosmoBolognaLib.Pair1D_comoving_log_swigregister
Pair1D_comoving_log_swigregister(Pair1D_comoving_log)

class Pair2D(Pair):
    __swig_setmethods__ = {}
    for _s in [Pair]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair2D, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair2D, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair2D
    __del__ = lambda self: None

    def scale_D1(self, *args):
        return _CosmoBolognaLib.Pair2D_scale_D1(self, *args)

    def scale_D2(self, *args):
        return _CosmoBolognaLib.Pair2D_scale_D2(self, *args)

    def PP2D(self, *args):
        return _CosmoBolognaLib.Pair2D_PP2D(self, *args)

    def binSize_inv_D1(self):
        return _CosmoBolognaLib.Pair2D_binSize_inv_D1(self)

    def nbins_D1(self):
        return _CosmoBolognaLib.Pair2D_nbins_D1(self)

    def shift_D1(self):
        return _CosmoBolognaLib.Pair2D_shift_D1(self)

    def binSize_inv_D2(self):
        return _CosmoBolognaLib.Pair2D_binSize_inv_D2(self)

    def nbins_D2(self):
        return _CosmoBolognaLib.Pair2D_nbins_D2(self)

    def shift_D2(self):
        return _CosmoBolognaLib.Pair2D_shift_D2(self)

    def set_scale_D1(self, i, pp):
        return _CosmoBolognaLib.Pair2D_set_scale_D1(self, i, pp)

    def set_scale_D2(self, i, pp):
        return _CosmoBolognaLib.Pair2D_set_scale_D2(self, i, pp)

    def set_PP2D(self, i, j, pp):
        return _CosmoBolognaLib.Pair2D_set_PP2D(self, i, j, pp)

    def add_data2D(self, *args):
        return _CosmoBolognaLib.Pair2D_add_data2D(self, *args)

    def Sum(self, pp, ww=1):
        return _CosmoBolognaLib.Pair2D_Sum(self, pp, ww)
Pair2D_swigregister = _CosmoBolognaLib.Pair2D_swigregister
Pair2D_swigregister(Pair2D)

class Pair2D_comovingCartesian(Pair2D):
    __swig_setmethods__ = {}
    for _s in [Pair2D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair2D_comovingCartesian, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair2D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair2D_comovingCartesian, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair2D_comovingCartesian
    __del__ = lambda self: None

    def sMin_D1(self):
        return _CosmoBolognaLib.Pair2D_comovingCartesian_sMin_D1(self)

    def sMax_D1(self):
        return _CosmoBolognaLib.Pair2D_comovingCartesian_sMax_D1(self)

    def sMin_D2(self):
        return _CosmoBolognaLib.Pair2D_comovingCartesian_sMin_D2(self)

    def sMax_D2(self):
        return _CosmoBolognaLib.Pair2D_comovingCartesian_sMax_D2(self)
Pair2D_comovingCartesian_swigregister = _CosmoBolognaLib.Pair2D_comovingCartesian_swigregister
Pair2D_comovingCartesian_swigregister(Pair2D_comovingCartesian)

class Pair2D_comovingCartesian_linlin(Pair2D_comovingCartesian):
    __swig_setmethods__ = {}
    for _s in [Pair2D_comovingCartesian]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair2D_comovingCartesian_linlin, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair2D_comovingCartesian]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair2D_comovingCartesian_linlin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Pair2D_comovingCartesian_linlin(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair2D_comovingCartesian_linlin
    __del__ = lambda self: None

    def put(self, obj1, obj2):
        return _CosmoBolognaLib.Pair2D_comovingCartesian_linlin_put(self, obj1, obj2)
Pair2D_comovingCartesian_linlin_swigregister = _CosmoBolognaLib.Pair2D_comovingCartesian_linlin_swigregister
Pair2D_comovingCartesian_linlin_swigregister(Pair2D_comovingCartesian_linlin)

class Pair2D_comovingCartesian_loglin(Pair2D_comovingCartesian):
    __swig_setmethods__ = {}
    for _s in [Pair2D_comovingCartesian]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair2D_comovingCartesian_loglin, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair2D_comovingCartesian]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair2D_comovingCartesian_loglin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Pair2D_comovingCartesian_loglin(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair2D_comovingCartesian_loglin
    __del__ = lambda self: None

    def put(self, obj1, obj2):
        return _CosmoBolognaLib.Pair2D_comovingCartesian_loglin_put(self, obj1, obj2)
Pair2D_comovingCartesian_loglin_swigregister = _CosmoBolognaLib.Pair2D_comovingCartesian_loglin_swigregister
Pair2D_comovingCartesian_loglin_swigregister(Pair2D_comovingCartesian_loglin)

class Pair2D_comovingCartesian_linlog(Pair2D_comovingCartesian):
    __swig_setmethods__ = {}
    for _s in [Pair2D_comovingCartesian]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair2D_comovingCartesian_linlog, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair2D_comovingCartesian]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair2D_comovingCartesian_linlog, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Pair2D_comovingCartesian_linlog(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair2D_comovingCartesian_linlog
    __del__ = lambda self: None

    def put(self, obj1, obj2):
        return _CosmoBolognaLib.Pair2D_comovingCartesian_linlog_put(self, obj1, obj2)
Pair2D_comovingCartesian_linlog_swigregister = _CosmoBolognaLib.Pair2D_comovingCartesian_linlog_swigregister
Pair2D_comovingCartesian_linlog_swigregister(Pair2D_comovingCartesian_linlog)

class Pair2D_comovingCartesian_loglog(Pair2D_comovingCartesian):
    __swig_setmethods__ = {}
    for _s in [Pair2D_comovingCartesian]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair2D_comovingCartesian_loglog, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair2D_comovingCartesian]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair2D_comovingCartesian_loglog, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Pair2D_comovingCartesian_loglog(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair2D_comovingCartesian_loglog
    __del__ = lambda self: None

    def put(self, obj1, obj2):
        return _CosmoBolognaLib.Pair2D_comovingCartesian_loglog_put(self, obj1, obj2)
Pair2D_comovingCartesian_loglog_swigregister = _CosmoBolognaLib.Pair2D_comovingCartesian_loglog_swigregister
Pair2D_comovingCartesian_loglog_swigregister(Pair2D_comovingCartesian_loglog)

class Pair2D_comovingPolar(Pair2D):
    __swig_setmethods__ = {}
    for _s in [Pair2D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair2D_comovingPolar, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair2D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair2D_comovingPolar, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair2D_comovingPolar
    __del__ = lambda self: None

    def sMin_D1(self):
        return _CosmoBolognaLib.Pair2D_comovingPolar_sMin_D1(self)

    def sMax_D1(self):
        return _CosmoBolognaLib.Pair2D_comovingPolar_sMax_D1(self)

    def sMin_D2(self):
        return _CosmoBolognaLib.Pair2D_comovingPolar_sMin_D2(self)

    def sMax_D2(self):
        return _CosmoBolognaLib.Pair2D_comovingPolar_sMax_D2(self)
Pair2D_comovingPolar_swigregister = _CosmoBolognaLib.Pair2D_comovingPolar_swigregister
Pair2D_comovingPolar_swigregister(Pair2D_comovingPolar)

class Pair2D_comovingPolar_linlin(Pair2D_comovingPolar):
    __swig_setmethods__ = {}
    for _s in [Pair2D_comovingPolar]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair2D_comovingPolar_linlin, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair2D_comovingPolar]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair2D_comovingPolar_linlin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Pair2D_comovingPolar_linlin(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair2D_comovingPolar_linlin
    __del__ = lambda self: None

    def put(self, obj1, obj2):
        return _CosmoBolognaLib.Pair2D_comovingPolar_linlin_put(self, obj1, obj2)
Pair2D_comovingPolar_linlin_swigregister = _CosmoBolognaLib.Pair2D_comovingPolar_linlin_swigregister
Pair2D_comovingPolar_linlin_swigregister(Pair2D_comovingPolar_linlin)

class Pair2D_comovingPolar_loglin(Pair2D_comovingPolar):
    __swig_setmethods__ = {}
    for _s in [Pair2D_comovingPolar]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair2D_comovingPolar_loglin, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair2D_comovingPolar]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair2D_comovingPolar_loglin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Pair2D_comovingPolar_loglin(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair2D_comovingPolar_loglin
    __del__ = lambda self: None

    def put(self, obj1, obj2):
        return _CosmoBolognaLib.Pair2D_comovingPolar_loglin_put(self, obj1, obj2)
Pair2D_comovingPolar_loglin_swigregister = _CosmoBolognaLib.Pair2D_comovingPolar_loglin_swigregister
Pair2D_comovingPolar_loglin_swigregister(Pair2D_comovingPolar_loglin)

class Pair2D_comovingPolar_linlog(Pair2D_comovingPolar):
    __swig_setmethods__ = {}
    for _s in [Pair2D_comovingPolar]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair2D_comovingPolar_linlog, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair2D_comovingPolar]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair2D_comovingPolar_linlog, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Pair2D_comovingPolar_linlog(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair2D_comovingPolar_linlog
    __del__ = lambda self: None

    def put(self, obj1, obj2):
        return _CosmoBolognaLib.Pair2D_comovingPolar_linlog_put(self, obj1, obj2)
Pair2D_comovingPolar_linlog_swigregister = _CosmoBolognaLib.Pair2D_comovingPolar_linlog_swigregister
Pair2D_comovingPolar_linlog_swigregister(Pair2D_comovingPolar_linlog)

class Pair2D_comovingPolar_loglog(Pair2D_comovingPolar):
    __swig_setmethods__ = {}
    for _s in [Pair2D_comovingPolar]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pair2D_comovingPolar_loglog, name, value)
    __swig_getmethods__ = {}
    for _s in [Pair2D_comovingPolar]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pair2D_comovingPolar_loglog, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Pair2D_comovingPolar_loglog(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Pair2D_comovingPolar_loglog
    __del__ = lambda self: None

    def put(self, obj1, obj2):
        return _CosmoBolognaLib.Pair2D_comovingPolar_loglog_put(self, obj1, obj2)
Pair2D_comovingPolar_loglog_swigregister = _CosmoBolognaLib.Pair2D_comovingPolar_loglog_swigregister
Pair2D_comovingPolar_loglog_swigregister(Pair2D_comovingPolar_loglog)


_CosmoBolognaLib._Poisson__swigconstant(_CosmoBolognaLib)
_Poisson_ = _CosmoBolognaLib._Poisson_

_CosmoBolognaLib._Jackknife__swigconstant(_CosmoBolognaLib)
_Jackknife_ = _CosmoBolognaLib._Jackknife_

_CosmoBolognaLib._Bootstrap__swigconstant(_CosmoBolognaLib)
_Bootstrap_ = _CosmoBolognaLib._Bootstrap_

_CosmoBolognaLib._1D_monopole__swigconstant(_CosmoBolognaLib)
_1D_monopole_ = _CosmoBolognaLib._1D_monopole_

_CosmoBolognaLib._1D_projected__swigconstant(_CosmoBolognaLib)
_1D_projected_ = _CosmoBolognaLib._1D_projected_

_CosmoBolognaLib._1D_deprojected__swigconstant(_CosmoBolognaLib)
_1D_deprojected_ = _CosmoBolognaLib._1D_deprojected_

_CosmoBolognaLib._1D_multipoles__swigconstant(_CosmoBolognaLib)
_1D_multipoles_ = _CosmoBolognaLib._1D_multipoles_

_CosmoBolognaLib._1D_wedges__swigconstant(_CosmoBolognaLib)
_1D_wedges_ = _CosmoBolognaLib._1D_wedges_

_CosmoBolognaLib._1D_filtered__swigconstant(_CosmoBolognaLib)
_1D_filtered_ = _CosmoBolognaLib._1D_filtered_

_CosmoBolognaLib._1D_angular__swigconstant(_CosmoBolognaLib)
_1D_angular_ = _CosmoBolognaLib._1D_angular_

_CosmoBolognaLib._2D_Cartesian__swigconstant(_CosmoBolognaLib)
_2D_Cartesian_ = _CosmoBolognaLib._2D_Cartesian_

_CosmoBolognaLib._2D_polar__swigconstant(_CosmoBolognaLib)
_2D_polar_ = _CosmoBolognaLib._2D_polar_

_CosmoBolognaLib._natural__swigconstant(_CosmoBolognaLib)
_natural_ = _CosmoBolognaLib._natural_

_CosmoBolognaLib._LandySzalay__swigconstant(_CosmoBolognaLib)
_LandySzalay_ = _CosmoBolognaLib._LandySzalay_
class TwoPointCorrelation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TwoPointCorrelation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TwoPointCorrelation, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_TwoPointCorrelation
    __del__ = lambda self: None
    __swig_getmethods__["Create"] = lambda x: _CosmoBolognaLib.TwoPointCorrelation_Create
    if _newclass:
        Create = staticmethod(_CosmoBolognaLib.TwoPointCorrelation_Create)

    def twoPType(self):
        return _CosmoBolognaLib.TwoPointCorrelation_twoPType(self)

    def dataset(self):
        return _CosmoBolognaLib.TwoPointCorrelation_dataset(self)

    def data(self):
        return _CosmoBolognaLib.TwoPointCorrelation_data(self)

    def random(self):
        return _CosmoBolognaLib.TwoPointCorrelation_random(self)

    def dd(self):
        return _CosmoBolognaLib.TwoPointCorrelation_dd(self)

    def rr(self):
        return _CosmoBolognaLib.TwoPointCorrelation_rr(self)

    def dr(self):
        return _CosmoBolognaLib.TwoPointCorrelation_dr(self)

    def compute_extra_info(self):
        return _CosmoBolognaLib.TwoPointCorrelation_compute_extra_info(self)

    def xx(self):
        return _CosmoBolognaLib.TwoPointCorrelation_xx(self)

    def yy(self):
        return _CosmoBolognaLib.TwoPointCorrelation_yy(self)

    def xi1D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_xi1D(self)

    def error1D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_error1D(self)

    def xi2D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_xi2D(self)

    def error2D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_error2D(self)

    def xiMonopole(self):
        return _CosmoBolognaLib.TwoPointCorrelation_xiMonopole(self)

    def errorMonopole(self):
        return _CosmoBolognaLib.TwoPointCorrelation_errorMonopole(self)

    def xiQuadrupole(self):
        return _CosmoBolognaLib.TwoPointCorrelation_xiQuadrupole(self)

    def errorQuadrupole(self):
        return _CosmoBolognaLib.TwoPointCorrelation_errorQuadrupole(self)

    def xiOctupole(self):
        return _CosmoBolognaLib.TwoPointCorrelation_xiOctupole(self)

    def errorOctupole(self):
        return _CosmoBolognaLib.TwoPointCorrelation_errorOctupole(self)

    def xiPerpendicular(self):
        return _CosmoBolognaLib.TwoPointCorrelation_xiPerpendicular(self)

    def errorPerpendicular(self):
        return _CosmoBolognaLib.TwoPointCorrelation_errorPerpendicular(self)

    def xiParallel(self):
        return _CosmoBolognaLib.TwoPointCorrelation_xiParallel(self)

    def errorParallel(self):
        return _CosmoBolognaLib.TwoPointCorrelation_errorParallel(self)

    def set_data(self, data):
        return _CosmoBolognaLib.TwoPointCorrelation_set_data(self, data)

    def set_random(self, random):
        return _CosmoBolognaLib.TwoPointCorrelation_set_random(self, random)

    def measure(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation_measure(self, *args)

    def read(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation_read(self, dir, file)

    def write(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation_write(self, *args)

    def read_covariance_matrix(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation_read_covariance_matrix(self, dir, file)

    def write_covariance_matrix(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation_write_covariance_matrix(self, dir, file)

    def compute_covariance_matrix(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation_compute_covariance_matrix(self, *args)

    def PoissonError(self, dd, rr, dr, nData, nRandom):
        return _CosmoBolognaLib.TwoPointCorrelation_PoissonError(self, dd, rr, dr, nData, nRandom)
TwoPointCorrelation_swigregister = _CosmoBolognaLib.TwoPointCorrelation_swigregister
TwoPointCorrelation_swigregister(TwoPointCorrelation)

def TwoPointCorrelation_Create(*args):
    return _CosmoBolognaLib.TwoPointCorrelation_Create(*args)
TwoPointCorrelation_Create = _CosmoBolognaLib.TwoPointCorrelation_Create

class TwoPointCorrelation1D(TwoPointCorrelation):
    __swig_setmethods__ = {}
    for _s in [TwoPointCorrelation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TwoPointCorrelation1D, name, value)
    __swig_getmethods__ = {}
    for _s in [TwoPointCorrelation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TwoPointCorrelation1D, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_TwoPointCorrelation1D
    __del__ = lambda self: None

    def xx(self):
        return _CosmoBolognaLib.TwoPointCorrelation1D_xx(self)

    def xi1D(self):
        return _CosmoBolognaLib.TwoPointCorrelation1D_xi1D(self)

    def error1D(self):
        return _CosmoBolognaLib.TwoPointCorrelation1D_error1D(self)

    def measure(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation1D_measure(self, *args)

    def read(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation1D_read(self, dir, file)

    def write(self, dir, file, rank=0):
        return _CosmoBolognaLib.TwoPointCorrelation1D_write(self, dir, file, rank)

    def read_covariance_matrix(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation1D_read_covariance_matrix(self, dir, file)

    def write_covariance_matrix(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation1D_write_covariance_matrix(self, dir, file)

    def compute_covariance_matrix(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation1D_compute_covariance_matrix(self, *args)
TwoPointCorrelation1D_swigregister = _CosmoBolognaLib.TwoPointCorrelation1D_swigregister
TwoPointCorrelation1D_swigregister(TwoPointCorrelation1D)

class TwoPointCorrelation1D_angular(TwoPointCorrelation1D):
    __swig_setmethods__ = {}
    for _s in [TwoPointCorrelation1D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TwoPointCorrelation1D_angular, name, value)
    __swig_getmethods__ = {}
    for _s in [TwoPointCorrelation1D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TwoPointCorrelation1D_angular, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_TwoPointCorrelation1D_angular(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_TwoPointCorrelation1D_angular
    __del__ = lambda self: None

    def set_parameters(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation1D_angular_set_parameters(self, *args)

    def measure(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation1D_angular_measure(self, *args)

    def read(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation1D_angular_read(self, dir, file)

    def write(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation1D_angular_write(self, *args)
TwoPointCorrelation1D_angular_swigregister = _CosmoBolognaLib.TwoPointCorrelation1D_angular_swigregister
TwoPointCorrelation1D_angular_swigregister(TwoPointCorrelation1D_angular)

class TwoPointCorrelation1D_monopole(TwoPointCorrelation1D):
    __swig_setmethods__ = {}
    for _s in [TwoPointCorrelation1D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TwoPointCorrelation1D_monopole, name, value)
    __swig_getmethods__ = {}
    for _s in [TwoPointCorrelation1D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TwoPointCorrelation1D_monopole, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_TwoPointCorrelation1D_monopole(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_TwoPointCorrelation1D_monopole
    __del__ = lambda self: None

    def set_parameters(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation1D_monopole_set_parameters(self, *args)

    def measure(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation1D_monopole_measure(self, *args)

    def read(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation1D_monopole_read(self, dir, file)

    def write(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation1D_monopole_write(self, *args)
TwoPointCorrelation1D_monopole_swigregister = _CosmoBolognaLib.TwoPointCorrelation1D_monopole_swigregister
TwoPointCorrelation1D_monopole_swigregister(TwoPointCorrelation1D_monopole)

class TwoPointCorrelation2D(TwoPointCorrelation):
    __swig_setmethods__ = {}
    for _s in [TwoPointCorrelation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TwoPointCorrelation2D, name, value)
    __swig_getmethods__ = {}
    for _s in [TwoPointCorrelation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TwoPointCorrelation2D, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_TwoPointCorrelation2D
    __del__ = lambda self: None

    def xx(self):
        return _CosmoBolognaLib.TwoPointCorrelation2D_xx(self)

    def yy(self):
        return _CosmoBolognaLib.TwoPointCorrelation2D_yy(self)

    def xi2D(self):
        return _CosmoBolognaLib.TwoPointCorrelation2D_xi2D(self)

    def error2D(self):
        return _CosmoBolognaLib.TwoPointCorrelation2D_error2D(self)

    def measure(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation2D_measure(self, *args)

    def read(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation2D_read(self, dir, file)

    def write(self, dir, file, rank=0):
        return _CosmoBolognaLib.TwoPointCorrelation2D_write(self, dir, file, rank)
TwoPointCorrelation2D_swigregister = _CosmoBolognaLib.TwoPointCorrelation2D_swigregister
TwoPointCorrelation2D_swigregister(TwoPointCorrelation2D)

class TwoPointCorrelation2D_cartesian(TwoPointCorrelation2D):
    __swig_setmethods__ = {}
    for _s in [TwoPointCorrelation2D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TwoPointCorrelation2D_cartesian, name, value)
    __swig_getmethods__ = {}
    for _s in [TwoPointCorrelation2D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TwoPointCorrelation2D_cartesian, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_TwoPointCorrelation2D_cartesian(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_TwoPointCorrelation2D_cartesian
    __del__ = lambda self: None

    def set_parameters(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation2D_cartesian_set_parameters(self, *args)

    def measure(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation2D_cartesian_measure(self, *args)

    def read(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation2D_cartesian_read(self, dir, file)

    def write(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation2D_cartesian_write(self, *args)
TwoPointCorrelation2D_cartesian_swigregister = _CosmoBolognaLib.TwoPointCorrelation2D_cartesian_swigregister
TwoPointCorrelation2D_cartesian_swigregister(TwoPointCorrelation2D_cartesian)

class TwoPointCorrelation2D_polar(TwoPointCorrelation2D):
    __swig_setmethods__ = {}
    for _s in [TwoPointCorrelation2D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TwoPointCorrelation2D_polar, name, value)
    __swig_getmethods__ = {}
    for _s in [TwoPointCorrelation2D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TwoPointCorrelation2D_polar, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_TwoPointCorrelation2D_polar(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_TwoPointCorrelation2D_polar
    __del__ = lambda self: None

    def set_parameters(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation2D_polar_set_parameters(self, *args)

    def measure(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation2D_polar_measure(self, *args)

    def read(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation2D_polar_read(self, dir, file)

    def write(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation2D_polar_write(self, *args)
TwoPointCorrelation2D_polar_swigregister = _CosmoBolognaLib.TwoPointCorrelation2D_polar_swigregister
TwoPointCorrelation2D_polar_swigregister(TwoPointCorrelation2D_polar)

class TwoPointCorrelation_projected(TwoPointCorrelation2D_cartesian):
    __swig_setmethods__ = {}
    for _s in [TwoPointCorrelation2D_cartesian]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TwoPointCorrelation_projected, name, value)
    __swig_getmethods__ = {}
    for _s in [TwoPointCorrelation2D_cartesian]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TwoPointCorrelation_projected, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_TwoPointCorrelation_projected(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_TwoPointCorrelation_projected
    __del__ = lambda self: None

    def yy(self):
        return _CosmoBolognaLib.TwoPointCorrelation_projected_yy(self)

    def xi1D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_projected_xi1D(self)

    def error1D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_projected_error1D(self)

    def xi2D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_projected_xi2D(self)

    def error2D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_projected_error2D(self)

    def measure(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation_projected_measure(self, *args)

    def read(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation_projected_read(self, dir, file)

    def write(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation_projected_write(self, *args)

    def read_covariance_matrix(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation_projected_read_covariance_matrix(self, dir, file)

    def write_covariance_matrix(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation_projected_write_covariance_matrix(self, dir, file)

    def compute_covariance_matrix(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation_projected_compute_covariance_matrix(self, *args)
TwoPointCorrelation_projected_swigregister = _CosmoBolognaLib.TwoPointCorrelation_projected_swigregister
TwoPointCorrelation_projected_swigregister(TwoPointCorrelation_projected)

class TwoPointCorrelation_deprojected(TwoPointCorrelation_projected):
    __swig_setmethods__ = {}
    for _s in [TwoPointCorrelation_projected]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TwoPointCorrelation_deprojected, name, value)
    __swig_getmethods__ = {}
    for _s in [TwoPointCorrelation_projected]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TwoPointCorrelation_deprojected, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_TwoPointCorrelation_deprojected(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_TwoPointCorrelation_deprojected
    __del__ = lambda self: None

    def yy(self):
        return _CosmoBolognaLib.TwoPointCorrelation_deprojected_yy(self)

    def xi1D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_deprojected_xi1D(self)

    def error1D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_deprojected_error1D(self)

    def xi2D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_deprojected_xi2D(self)

    def error2D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_deprojected_error2D(self)

    def measure(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation_deprojected_measure(self, *args)

    def read(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation_deprojected_read(self, dir, file)

    def write(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation_deprojected_write(self, *args)

    def read_covariance_matrix(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation_deprojected_read_covariance_matrix(self, dir, file)

    def write_covariance_matrix(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation_deprojected_write_covariance_matrix(self, dir, file)

    def compute_covariance_matrix(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation_deprojected_compute_covariance_matrix(self, *args)
TwoPointCorrelation_deprojected_swigregister = _CosmoBolognaLib.TwoPointCorrelation_deprojected_swigregister
TwoPointCorrelation_deprojected_swigregister(TwoPointCorrelation_deprojected)

class TwoPointCorrelation_multipoles(TwoPointCorrelation2D_polar):
    __swig_setmethods__ = {}
    for _s in [TwoPointCorrelation2D_polar]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TwoPointCorrelation_multipoles, name, value)
    __swig_getmethods__ = {}
    for _s in [TwoPointCorrelation2D_polar]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TwoPointCorrelation_multipoles, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_TwoPointCorrelation_multipoles(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_TwoPointCorrelation_multipoles
    __del__ = lambda self: None

    def xx(self):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_xx(self)

    def yy(self):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_yy(self)

    def xi1D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_xi1D(self)

    def error1D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_error1D(self)

    def xi2D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_xi2D(self)

    def error2D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_error2D(self)

    def xiMonopole(self):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_xiMonopole(self)

    def errorMonopole(self):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_errorMonopole(self)

    def xiQuadrupole(self):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_xiQuadrupole(self)

    def errorQuadrupole(self):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_errorQuadrupole(self)

    def xiOctupole(self):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_xiOctupole(self)

    def errorOctupole(self):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_errorOctupole(self)

    def measure(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_measure(self, *args)

    def read(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_read(self, dir, file)

    def write(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_write(self, *args)

    def read_covariance_matrix(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_read_covariance_matrix(self, dir, file)

    def write_covariance_matrix(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_write_covariance_matrix(self, dir, file)

    def compute_covariance_matrix(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation_multipoles_compute_covariance_matrix(self, *args)
TwoPointCorrelation_multipoles_swigregister = _CosmoBolognaLib.TwoPointCorrelation_multipoles_swigregister
TwoPointCorrelation_multipoles_swigregister(TwoPointCorrelation_multipoles)

class TwoPointCorrelation_wedges(TwoPointCorrelation2D_polar):
    __swig_setmethods__ = {}
    for _s in [TwoPointCorrelation2D_polar]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TwoPointCorrelation_wedges, name, value)
    __swig_getmethods__ = {}
    for _s in [TwoPointCorrelation2D_polar]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TwoPointCorrelation_wedges, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_TwoPointCorrelation_wedges(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_TwoPointCorrelation_wedges
    __del__ = lambda self: None

    def xx(self):
        return _CosmoBolognaLib.TwoPointCorrelation_wedges_xx(self)

    def xiPerpendicular(self):
        return _CosmoBolognaLib.TwoPointCorrelation_wedges_xiPerpendicular(self)

    def errorPerpendicular(self):
        return _CosmoBolognaLib.TwoPointCorrelation_wedges_errorPerpendicular(self)

    def xiParallel(self):
        return _CosmoBolognaLib.TwoPointCorrelation_wedges_xiParallel(self)

    def errorParallel(self):
        return _CosmoBolognaLib.TwoPointCorrelation_wedges_errorParallel(self)

    def yy(self):
        return _CosmoBolognaLib.TwoPointCorrelation_wedges_yy(self)

    def xi1D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_wedges_xi1D(self)

    def error1D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_wedges_error1D(self)

    def xi2D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_wedges_xi2D(self)

    def error2D(self):
        return _CosmoBolognaLib.TwoPointCorrelation_wedges_error2D(self)

    def measure(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation_wedges_measure(self, *args)

    def read(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation_wedges_read(self, dir, file)

    def write(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation_wedges_write(self, *args)

    def read_covariance_matrix(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation_wedges_read_covariance_matrix(self, dir, file)

    def write_covariance_matrix(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation_wedges_write_covariance_matrix(self, dir, file)

    def compute_covariance_matrix(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation_wedges_compute_covariance_matrix(self, *args)
TwoPointCorrelation_wedges_swigregister = _CosmoBolognaLib.TwoPointCorrelation_wedges_swigregister
TwoPointCorrelation_wedges_swigregister(TwoPointCorrelation_wedges)

class TwoPointCorrelation1D_filtered(TwoPointCorrelation1D_monopole):
    __swig_setmethods__ = {}
    for _s in [TwoPointCorrelation1D_monopole]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TwoPointCorrelation1D_filtered, name, value)
    __swig_getmethods__ = {}
    for _s in [TwoPointCorrelation1D_monopole]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TwoPointCorrelation1D_filtered, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_TwoPointCorrelation1D_filtered(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_TwoPointCorrelation1D_filtered
    __del__ = lambda self: None

    def set_parameters(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation1D_filtered_set_parameters(self, *args)

    def measure(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation1D_filtered_measure(self, *args)

    def read(self, dir, file):
        return _CosmoBolognaLib.TwoPointCorrelation1D_filtered_read(self, dir, file)

    def write(self, *args):
        return _CosmoBolognaLib.TwoPointCorrelation1D_filtered_write(self, *args)
TwoPointCorrelation1D_filtered_swigregister = _CosmoBolognaLib.TwoPointCorrelation1D_filtered_swigregister
TwoPointCorrelation1D_filtered_swigregister(TwoPointCorrelation1D_filtered)

class TwoPointCorrelationPtr(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TwoPointCorrelationPtr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TwoPointCorrelationPtr, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _CosmoBolognaLib.new_TwoPointCorrelationPtr()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_TwoPointCorrelationPtr
    __del__ = lambda self: None
TwoPointCorrelationPtr_swigregister = _CosmoBolognaLib.TwoPointCorrelationPtr_swigregister
TwoPointCorrelationPtr_swigregister(TwoPointCorrelationPtr)


_CosmoBolognaLib._comoving_theta__swigconstant(_CosmoBolognaLib)
_comoving_theta_ = _CosmoBolognaLib._comoving_theta_

_CosmoBolognaLib._comoving_side__swigconstant(_CosmoBolognaLib)
_comoving_side_ = _CosmoBolognaLib._comoving_side_
class Triplet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Triplet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Triplet, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_Triplet
    __del__ = lambda self: None
    __swig_getmethods__["Create"] = lambda x: _CosmoBolognaLib.Triplet_Create
    if _newclass:
        Create = staticmethod(_CosmoBolognaLib.Triplet_Create)

    def tripletDim(self):
        return _CosmoBolognaLib.Triplet_tripletDim(self)

    def tripletType(self):
        return _CosmoBolognaLib.Triplet_tripletType(self)

    def scale(self, *args):
        return _CosmoBolognaLib.Triplet_scale(self, *args)

    def TT1D(self, *args):
        return _CosmoBolognaLib.Triplet_TT1D(self, *args)

    def scale_D1(self, *args):
        return _CosmoBolognaLib.Triplet_scale_D1(self, *args)

    def scale_D2(self, *args):
        return _CosmoBolognaLib.Triplet_scale_D2(self, *args)

    def TT2D(self, *args):
        return _CosmoBolognaLib.Triplet_TT2D(self, *args)

    def side_s(self):
        return _CosmoBolognaLib.Triplet_side_s(self)

    def side_u(self):
        return _CosmoBolognaLib.Triplet_side_u(self)

    def perc_increase(self):
        return _CosmoBolognaLib.Triplet_perc_increase(self)

    def nbins(self):
        return _CosmoBolognaLib.Triplet_nbins(self)

    def binSize(self):
        return _CosmoBolognaLib.Triplet_binSize(self)

    def side_s_D1(self):
        return _CosmoBolognaLib.Triplet_side_s_D1(self)

    def side_u_D1(self):
        return _CosmoBolognaLib.Triplet_side_u_D1(self)

    def perc_increase_D1(self):
        return _CosmoBolognaLib.Triplet_perc_increase_D1(self)

    def nbins_D1(self):
        return _CosmoBolognaLib.Triplet_nbins_D1(self)

    def binSize_D1(self):
        return _CosmoBolognaLib.Triplet_binSize_D1(self)

    def side_s_D2(self):
        return _CosmoBolognaLib.Triplet_side_s_D2(self)

    def side_u_D2(self):
        return _CosmoBolognaLib.Triplet_side_u_D2(self)

    def perc_increase_D2(self):
        return _CosmoBolognaLib.Triplet_perc_increase_D2(self)

    def nbins_D2(self):
        return _CosmoBolognaLib.Triplet_nbins_D2(self)

    def binSize_D2(self):
        return _CosmoBolognaLib.Triplet_binSize_D2(self)

    def set_TT1D(self, i, tt):
        return _CosmoBolognaLib.Triplet_set_TT1D(self, i, tt)

    def add_TT1D(self, i, tt):
        return _CosmoBolognaLib.Triplet_add_TT1D(self, i, tt)

    def put(self, *args):
        return _CosmoBolognaLib.Triplet_put(self, *args)

    def Sum(self, tt, ww=1.):
        return _CosmoBolognaLib.Triplet_Sum(self, tt, ww)
Triplet_swigregister = _CosmoBolognaLib.Triplet_swigregister
Triplet_swigregister(Triplet)

def Triplet_Create(type, side_s, side_u, perc_increase, nbins):
    return _CosmoBolognaLib.Triplet_Create(type, side_s, side_u, perc_increase, nbins)
Triplet_Create = _CosmoBolognaLib.Triplet_Create

class Triplet1D(Triplet):
    __swig_setmethods__ = {}
    for _s in [Triplet]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Triplet1D, name, value)
    __swig_getmethods__ = {}
    for _s in [Triplet]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Triplet1D, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_Triplet1D
    __del__ = lambda self: None

    def scale(self, *args):
        return _CosmoBolognaLib.Triplet1D_scale(self, *args)

    def TT1D(self, *args):
        return _CosmoBolognaLib.Triplet1D_TT1D(self, *args)

    def side_s(self):
        return _CosmoBolognaLib.Triplet1D_side_s(self)

    def side_u(self):
        return _CosmoBolognaLib.Triplet1D_side_u(self)

    def perc_increase(self):
        return _CosmoBolognaLib.Triplet1D_perc_increase(self)

    def nbins(self):
        return _CosmoBolognaLib.Triplet1D_nbins(self)

    def binSize(self):
        return _CosmoBolognaLib.Triplet1D_binSize(self)

    def set_TT1D(self, i, tt):
        return _CosmoBolognaLib.Triplet1D_set_TT1D(self, i, tt)

    def add_TT1D(self, i, tt):
        return _CosmoBolognaLib.Triplet1D_add_TT1D(self, i, tt)

    def Sum(self, tt, ww=1):
        return _CosmoBolognaLib.Triplet1D_Sum(self, tt, ww)
Triplet1D_swigregister = _CosmoBolognaLib.Triplet1D_swigregister
Triplet1D_swigregister(Triplet1D)

class Triplet1D_comoving(Triplet1D):
    __swig_setmethods__ = {}
    for _s in [Triplet1D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Triplet1D_comoving, name, value)
    __swig_getmethods__ = {}
    for _s in [Triplet1D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Triplet1D_comoving, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_Triplet1D_comoving
    __del__ = lambda self: None
Triplet1D_comoving_swigregister = _CosmoBolognaLib.Triplet1D_comoving_swigregister
Triplet1D_comoving_swigregister(Triplet1D_comoving)

class Triplet1D_comoving_theta(Triplet1D_comoving):
    __swig_setmethods__ = {}
    for _s in [Triplet1D_comoving]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Triplet1D_comoving_theta, name, value)
    __swig_getmethods__ = {}
    for _s in [Triplet1D_comoving]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Triplet1D_comoving_theta, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Triplet1D_comoving_theta(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def put(self, *args):
        return _CosmoBolognaLib.Triplet1D_comoving_theta_put(self, *args)
    __swig_destroy__ = _CosmoBolognaLib.delete_Triplet1D_comoving_theta
    __del__ = lambda self: None
Triplet1D_comoving_theta_swigregister = _CosmoBolognaLib.Triplet1D_comoving_theta_swigregister
Triplet1D_comoving_theta_swigregister(Triplet1D_comoving_theta)

class Triplet1D_comoving_side(Triplet1D_comoving):
    __swig_setmethods__ = {}
    for _s in [Triplet1D_comoving]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Triplet1D_comoving_side, name, value)
    __swig_getmethods__ = {}
    for _s in [Triplet1D_comoving]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Triplet1D_comoving_side, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Triplet1D_comoving_side(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def put(self, *args):
        return _CosmoBolognaLib.Triplet1D_comoving_side_put(self, *args)
    __swig_destroy__ = _CosmoBolognaLib.delete_Triplet1D_comoving_side
    __del__ = lambda self: None
Triplet1D_comoving_side_swigregister = _CosmoBolognaLib.Triplet1D_comoving_side_swigregister
Triplet1D_comoving_side_swigregister(Triplet1D_comoving_side)

class Triplet1D_angular(Triplet1D):
    __swig_setmethods__ = {}
    for _s in [Triplet1D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Triplet1D_angular, name, value)
    __swig_getmethods__ = {}
    for _s in [Triplet1D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Triplet1D_angular, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_Triplet1D_angular
    __del__ = lambda self: None
Triplet1D_angular_swigregister = _CosmoBolognaLib.Triplet1D_angular_swigregister
Triplet1D_angular_swigregister(Triplet1D_angular)

class Triplet2D(Triplet):
    __swig_setmethods__ = {}
    for _s in [Triplet]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Triplet2D, name, value)
    __swig_getmethods__ = {}
    for _s in [Triplet]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Triplet2D, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_Triplet2D
    __del__ = lambda self: None

    def scale_D1(self, *args):
        return _CosmoBolognaLib.Triplet2D_scale_D1(self, *args)

    def scale_D2(self, *args):
        return _CosmoBolognaLib.Triplet2D_scale_D2(self, *args)

    def TT2D(self, *args):
        return _CosmoBolognaLib.Triplet2D_TT2D(self, *args)

    def side_s_D1(self):
        return _CosmoBolognaLib.Triplet2D_side_s_D1(self)

    def side_u_D1(self):
        return _CosmoBolognaLib.Triplet2D_side_u_D1(self)

    def perc_increase_D1(self):
        return _CosmoBolognaLib.Triplet2D_perc_increase_D1(self)

    def binSize_D1(self):
        return _CosmoBolognaLib.Triplet2D_binSize_D1(self)

    def side_s_D2(self):
        return _CosmoBolognaLib.Triplet2D_side_s_D2(self)

    def side_u_D2(self):
        return _CosmoBolognaLib.Triplet2D_side_u_D2(self)

    def perc_increase_D2(self):
        return _CosmoBolognaLib.Triplet2D_perc_increase_D2(self)

    def binSize_D2(self):
        return _CosmoBolognaLib.Triplet2D_binSize_D2(self)

    def Sum(self, tt, ww=1):
        return _CosmoBolognaLib.Triplet2D_Sum(self, tt, ww)

    def put(self, *args):
        return _CosmoBolognaLib.Triplet2D_put(self, *args)
Triplet2D_swigregister = _CosmoBolognaLib.Triplet2D_swigregister
Triplet2D_swigregister(Triplet2D)


_CosmoBolognaLib._angular_connected__swigconstant(_CosmoBolognaLib)
_angular_connected_ = _CosmoBolognaLib._angular_connected_

_CosmoBolognaLib._angular_reduced__swigconstant(_CosmoBolognaLib)
_angular_reduced_ = _CosmoBolognaLib._angular_reduced_

_CosmoBolognaLib._comoving_connected__swigconstant(_CosmoBolognaLib)
_comoving_connected_ = _CosmoBolognaLib._comoving_connected_

_CosmoBolognaLib._comoving_reduced__swigconstant(_CosmoBolognaLib)
_comoving_reduced_ = _CosmoBolognaLib._comoving_reduced_
class ThreePointCorrelation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThreePointCorrelation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ThreePointCorrelation, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_ThreePointCorrelation(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_ThreePointCorrelation
    __del__ = lambda self: None
    __swig_getmethods__["Create"] = lambda x: _CosmoBolognaLib.ThreePointCorrelation_Create
    if _newclass:
        Create = staticmethod(_CosmoBolognaLib.ThreePointCorrelation_Create)

    def data(self):
        return _CosmoBolognaLib.ThreePointCorrelation_data(self)

    def random(self):
        return _CosmoBolognaLib.ThreePointCorrelation_random(self)

    def ddd(self):
        return _CosmoBolognaLib.ThreePointCorrelation_ddd(self)

    def rrr(self):
        return _CosmoBolognaLib.ThreePointCorrelation_rrr(self)

    def ddr(self):
        return _CosmoBolognaLib.ThreePointCorrelation_ddr(self)

    def drr(self):
        return _CosmoBolognaLib.ThreePointCorrelation_drr(self)

    def scale(self):
        return _CosmoBolognaLib.ThreePointCorrelation_scale(self)

    def zeta(self):
        return _CosmoBolognaLib.ThreePointCorrelation_zeta(self)

    def QQ(self):
        return _CosmoBolognaLib.ThreePointCorrelation_QQ(self)

    def error(self):
        return _CosmoBolognaLib.ThreePointCorrelation_error(self)

    def set_data(self, data):
        return _CosmoBolognaLib.ThreePointCorrelation_set_data(self, data)

    def set_random(self, random):
        return _CosmoBolognaLib.ThreePointCorrelation_set_random(self, random)

    def measure(self, *args):
        return _CosmoBolognaLib.ThreePointCorrelation_measure(self, *args)

    def write(self, *args):
        return _CosmoBolognaLib.ThreePointCorrelation_write(self, *args)
ThreePointCorrelation_swigregister = _CosmoBolognaLib.ThreePointCorrelation_swigregister
ThreePointCorrelation_swigregister(ThreePointCorrelation)

def ThreePointCorrelation_Create(type, data, random, tripletType, side_s, side_u, perc_increase, nbins):
    return _CosmoBolognaLib.ThreePointCorrelation_Create(type, data, random, tripletType, side_s, side_u, perc_increase, nbins)
ThreePointCorrelation_Create = _CosmoBolognaLib.ThreePointCorrelation_Create

class ThreePointCorrelation_angular_connected(ThreePointCorrelation):
    __swig_setmethods__ = {}
    for _s in [ThreePointCorrelation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThreePointCorrelation_angular_connected, name, value)
    __swig_getmethods__ = {}
    for _s in [ThreePointCorrelation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ThreePointCorrelation_angular_connected, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_ThreePointCorrelation_angular_connected(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_ThreePointCorrelation_angular_connected
    __del__ = lambda self: None

    def set_parameters(self, side_s, side_u, perc_increase, nbins):
        return _CosmoBolognaLib.ThreePointCorrelation_angular_connected_set_parameters(self, side_s, side_u, perc_increase, nbins)

    def scale(self):
        return _CosmoBolognaLib.ThreePointCorrelation_angular_connected_scale(self)

    def zeta(self):
        return _CosmoBolognaLib.ThreePointCorrelation_angular_connected_zeta(self)

    def error(self):
        return _CosmoBolognaLib.ThreePointCorrelation_angular_connected_error(self)

    def measure(self, *args):
        return _CosmoBolognaLib.ThreePointCorrelation_angular_connected_measure(self, *args)

    def write(self, dir, file):
        return _CosmoBolognaLib.ThreePointCorrelation_angular_connected_write(self, dir, file)
ThreePointCorrelation_angular_connected_swigregister = _CosmoBolognaLib.ThreePointCorrelation_angular_connected_swigregister
ThreePointCorrelation_angular_connected_swigregister(ThreePointCorrelation_angular_connected)

class ThreePointCorrelation_angular_reduced(ThreePointCorrelation_angular_connected):
    __swig_setmethods__ = {}
    for _s in [ThreePointCorrelation_angular_connected]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThreePointCorrelation_angular_reduced, name, value)
    __swig_getmethods__ = {}
    for _s in [ThreePointCorrelation_angular_connected]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ThreePointCorrelation_angular_reduced, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_ThreePointCorrelation_angular_reduced(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_ThreePointCorrelation_angular_reduced
    __del__ = lambda self: None

    def measure(self, *args):
        return _CosmoBolognaLib.ThreePointCorrelation_angular_reduced_measure(self, *args)

    def write(self, dir, file, connected):
        return _CosmoBolognaLib.ThreePointCorrelation_angular_reduced_write(self, dir, file, connected)
ThreePointCorrelation_angular_reduced_swigregister = _CosmoBolognaLib.ThreePointCorrelation_angular_reduced_swigregister
ThreePointCorrelation_angular_reduced_swigregister(ThreePointCorrelation_angular_reduced)

class ThreePointCorrelation_comoving_connected(ThreePointCorrelation):
    __swig_setmethods__ = {}
    for _s in [ThreePointCorrelation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThreePointCorrelation_comoving_connected, name, value)
    __swig_getmethods__ = {}
    for _s in [ThreePointCorrelation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ThreePointCorrelation_comoving_connected, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_ThreePointCorrelation_comoving_connected(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_ThreePointCorrelation_comoving_connected
    __del__ = lambda self: None

    def set_parameters(self, tripletType, side_s, side_u, perc_increase, nbins):
        return _CosmoBolognaLib.ThreePointCorrelation_comoving_connected_set_parameters(self, tripletType, side_s, side_u, perc_increase, nbins)

    def scale(self):
        return _CosmoBolognaLib.ThreePointCorrelation_comoving_connected_scale(self)

    def zeta(self):
        return _CosmoBolognaLib.ThreePointCorrelation_comoving_connected_zeta(self)

    def error(self):
        return _CosmoBolognaLib.ThreePointCorrelation_comoving_connected_error(self)

    def measure(self, *args):
        return _CosmoBolognaLib.ThreePointCorrelation_comoving_connected_measure(self, *args)

    def write(self, dir, file):
        return _CosmoBolognaLib.ThreePointCorrelation_comoving_connected_write(self, dir, file)
ThreePointCorrelation_comoving_connected_swigregister = _CosmoBolognaLib.ThreePointCorrelation_comoving_connected_swigregister
ThreePointCorrelation_comoving_connected_swigregister(ThreePointCorrelation_comoving_connected)

class ThreePointCorrelation_comoving_reduced(ThreePointCorrelation_comoving_connected):
    __swig_setmethods__ = {}
    for _s in [ThreePointCorrelation_comoving_connected]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThreePointCorrelation_comoving_reduced, name, value)
    __swig_getmethods__ = {}
    for _s in [ThreePointCorrelation_comoving_connected]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ThreePointCorrelation_comoving_reduced, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_ThreePointCorrelation_comoving_reduced(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_ThreePointCorrelation_comoving_reduced
    __del__ = lambda self: None

    def scale(self):
        return _CosmoBolognaLib.ThreePointCorrelation_comoving_reduced_scale(self)

    def QQ(self):
        return _CosmoBolognaLib.ThreePointCorrelation_comoving_reduced_QQ(self)

    def error(self):
        return _CosmoBolognaLib.ThreePointCorrelation_comoving_reduced_error(self)

    def measure(self, *args):
        return _CosmoBolognaLib.ThreePointCorrelation_comoving_reduced_measure(self, *args)

    def write(self, dir, file, connected):
        return _CosmoBolognaLib.ThreePointCorrelation_comoving_reduced_write(self, dir, file, connected)
ThreePointCorrelation_comoving_reduced_swigregister = _CosmoBolognaLib.ThreePointCorrelation_comoving_reduced_swigregister
ThreePointCorrelation_comoving_reduced_swigregister(ThreePointCorrelation_comoving_reduced)

class Modelling(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Modelling, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Modelling, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _CosmoBolognaLib.new_Modelling()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Modelling
    __del__ = lambda self: None

    def data(self):
        return _CosmoBolognaLib.Modelling_data(self)

    def model(self):
        return _CosmoBolognaLib.Modelling_model(self)

    def likelihood(self):
        return _CosmoBolognaLib.Modelling_likelihood(self)

    def set_data(self, dataset):
        return _CosmoBolognaLib.Modelling_set_data(self, dataset)

    def set_model(self, model):
        return _CosmoBolognaLib.Modelling_set_model(self, model)

    def set_likelihood(self, *args):
        return _CosmoBolognaLib.Modelling_set_likelihood(self, *args)

    def sample_likelihood(self, *args):
        return _CosmoBolognaLib.Modelling_sample_likelihood(self, *args)

    def write_parameters(self, dir, file):
        return _CosmoBolognaLib.Modelling_write_parameters(self, dir, file)

    def write_model(self, *args):
        return _CosmoBolognaLib.Modelling_write_model(self, *args)
Modelling_swigregister = _CosmoBolognaLib.Modelling_swigregister
Modelling_swigregister(Modelling)

class Modelling_TwoPointCorrelation(Modelling):
    __swig_setmethods__ = {}
    for _s in [Modelling]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Modelling_TwoPointCorrelation, name, value)
    __swig_getmethods__ = {}
    for _s in [Modelling]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Modelling_TwoPointCorrelation, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_Modelling_TwoPointCorrelation
    __del__ = lambda self: None
    __swig_getmethods__["Create"] = lambda x: _CosmoBolognaLib.Modelling_TwoPointCorrelation_Create
    if _newclass:
        Create = staticmethod(_CosmoBolognaLib.Modelling_TwoPointCorrelation_Create)

    def alpha_bestfit(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_alpha_bestfit(self)

    def fsigma8_bestfit(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_fsigma8_bestfit(self)

    def bsigma8_bestfit(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_bsigma8_bestfit(self)

    def A0_bestfit(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_A0_bestfit(self)

    def A1_bestfit(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_A1_bestfit(self)

    def A2_bestfit(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_A2_bestfit(self)

    def twoPType(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_twoPType(self)

    def set_parameters_xiDM(self, *args):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_set_parameters_xiDM(self, *args)

    def set_parameters_xi2D_DM(self, *args):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_set_parameters_xi2D_DM(self, *args)

    def set_fiducial_xiDM(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_set_fiducial_xiDM(self)
Modelling_TwoPointCorrelation_swigregister = _CosmoBolognaLib.Modelling_TwoPointCorrelation_swigregister
Modelling_TwoPointCorrelation_swigregister(Modelling_TwoPointCorrelation)

def Modelling_TwoPointCorrelation_Create(*args):
    return _CosmoBolognaLib.Modelling_TwoPointCorrelation_Create(*args)
Modelling_TwoPointCorrelation_Create = _CosmoBolognaLib.Modelling_TwoPointCorrelation_Create

class Modelling_TwoPointCorrelation1D(Modelling_TwoPointCorrelation):
    __swig_setmethods__ = {}
    for _s in [Modelling_TwoPointCorrelation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Modelling_TwoPointCorrelation1D, name, value)
    __swig_getmethods__ = {}
    for _s in [Modelling_TwoPointCorrelation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Modelling_TwoPointCorrelation1D, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_Modelling_TwoPointCorrelation1D
    __del__ = lambda self: None

    def set_fiducial_xiDM(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation1D_set_fiducial_xiDM(self)

    def set_model_monopole(self, *args):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation1D_set_model_monopole(self, *args)

    def set_model_linearBias(self, *args):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation1D_set_model_linearBias(self, *args)

    def write_model(self, *args):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation1D_write_model(self, *args)
Modelling_TwoPointCorrelation1D_swigregister = _CosmoBolognaLib.Modelling_TwoPointCorrelation1D_swigregister
Modelling_TwoPointCorrelation1D_swigregister(Modelling_TwoPointCorrelation1D)

class Modelling_TwoPointCorrelation2D(Modelling_TwoPointCorrelation):
    __swig_setmethods__ = {}
    for _s in [Modelling_TwoPointCorrelation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Modelling_TwoPointCorrelation2D, name, value)
    __swig_getmethods__ = {}
    for _s in [Modelling_TwoPointCorrelation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Modelling_TwoPointCorrelation2D, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CosmoBolognaLib.delete_Modelling_TwoPointCorrelation2D
    __del__ = lambda self: None

    def set_fiducial_xiDM(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation2D_set_fiducial_xiDM(self)

    def set_model_dispersionModel(self, *args):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation2D_set_model_dispersionModel(self, *args)

    def write_model(self, *args):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation2D_write_model(self, *args)
Modelling_TwoPointCorrelation2D_swigregister = _CosmoBolognaLib.Modelling_TwoPointCorrelation2D_swigregister
Modelling_TwoPointCorrelation2D_swigregister(Modelling_TwoPointCorrelation2D)

class Modelling_TwoPointCorrelation_monopole(Modelling_TwoPointCorrelation1D):
    __swig_setmethods__ = {}
    for _s in [Modelling_TwoPointCorrelation1D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Modelling_TwoPointCorrelation_monopole, name, value)
    __swig_getmethods__ = {}
    for _s in [Modelling_TwoPointCorrelation1D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Modelling_TwoPointCorrelation_monopole, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Modelling_TwoPointCorrelation_monopole(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Modelling_TwoPointCorrelation_monopole
    __del__ = lambda self: None

    def alpha_bestfit(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_monopole_alpha_bestfit(self)

    def fsigma8_bestfit(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_monopole_fsigma8_bestfit(self)

    def bsigma8_bestfit(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_monopole_bsigma8_bestfit(self)

    def A0_bestfit(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_monopole_A0_bestfit(self)

    def A1_bestfit(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_monopole_A1_bestfit(self)

    def A2_bestfit(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_monopole_A2_bestfit(self)

    def set_fiducial_xiDM(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_monopole_set_fiducial_xiDM(self)

    def set_model_Kaiser(self, *args):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_monopole_set_model_Kaiser(self, *args)

    def set_model_BAO(self, *args):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_monopole_set_model_BAO(self, *args)
Modelling_TwoPointCorrelation_monopole_swigregister = _CosmoBolognaLib.Modelling_TwoPointCorrelation_monopole_swigregister
Modelling_TwoPointCorrelation_monopole_swigregister(Modelling_TwoPointCorrelation_monopole)

class Modelling_TwoPointCorrelation_deprojected(Modelling_TwoPointCorrelation1D):
    __swig_setmethods__ = {}
    for _s in [Modelling_TwoPointCorrelation1D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Modelling_TwoPointCorrelation_deprojected, name, value)
    __swig_getmethods__ = {}
    for _s in [Modelling_TwoPointCorrelation1D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Modelling_TwoPointCorrelation_deprojected, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Modelling_TwoPointCorrelation_deprojected(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Modelling_TwoPointCorrelation_deprojected
    __del__ = lambda self: None

    def set_fiducial_xiDM(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_deprojected_set_fiducial_xiDM(self)
Modelling_TwoPointCorrelation_deprojected_swigregister = _CosmoBolognaLib.Modelling_TwoPointCorrelation_deprojected_swigregister
Modelling_TwoPointCorrelation_deprojected_swigregister(Modelling_TwoPointCorrelation_deprojected)

class Modelling_TwoPointCorrelation_projected(Modelling_TwoPointCorrelation1D):
    __swig_setmethods__ = {}
    for _s in [Modelling_TwoPointCorrelation1D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Modelling_TwoPointCorrelation_projected, name, value)
    __swig_getmethods__ = {}
    for _s in [Modelling_TwoPointCorrelation1D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Modelling_TwoPointCorrelation_projected, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Modelling_TwoPointCorrelation_projected(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Modelling_TwoPointCorrelation_projected
    __del__ = lambda self: None

    def set_fiducial_xiDM(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_projected_set_fiducial_xiDM(self)
Modelling_TwoPointCorrelation_projected_swigregister = _CosmoBolognaLib.Modelling_TwoPointCorrelation_projected_swigregister
Modelling_TwoPointCorrelation_projected_swigregister(Modelling_TwoPointCorrelation_projected)

class Modelling_TwoPointCorrelation_cartesian(Modelling_TwoPointCorrelation2D):
    __swig_setmethods__ = {}
    for _s in [Modelling_TwoPointCorrelation2D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Modelling_TwoPointCorrelation_cartesian, name, value)
    __swig_getmethods__ = {}
    for _s in [Modelling_TwoPointCorrelation2D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Modelling_TwoPointCorrelation_cartesian, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_Modelling_TwoPointCorrelation_cartesian(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_Modelling_TwoPointCorrelation_cartesian
    __del__ = lambda self: None

    def set_fiducial_xiDM(self):
        return _CosmoBolognaLib.Modelling_TwoPointCorrelation_cartesian_set_fiducial_xiDM(self)
Modelling_TwoPointCorrelation_cartesian_swigregister = _CosmoBolognaLib.Modelling_TwoPointCorrelation_cartesian_swigregister
Modelling_TwoPointCorrelation_cartesian_swigregister(Modelling_TwoPointCorrelation_cartesian)


def __add__(c1, c2):
    return _CosmoBolognaLib.__add__(c1, c2)
__add__ = _CosmoBolognaLib.__add__

def Vmax_DC_distribution(*args):
    return _CosmoBolognaLib.Vmax_DC_distribution(*args)
Vmax_DC_distribution = _CosmoBolognaLib.Vmax_DC_distribution

def AP_shift_r(arg1, arg2, arg3):
    return _CosmoBolognaLib.AP_shift_r(arg1, arg2, arg3)
AP_shift_r = _CosmoBolognaLib.AP_shift_r

def AP_shift_rp(arg1, arg2, arg3):
    return _CosmoBolognaLib.AP_shift_rp(arg1, arg2, arg3)
AP_shift_rp = _CosmoBolognaLib.AP_shift_rp

def AP_shift_pi(arg1, arg2, arg3):
    return _CosmoBolognaLib.AP_shift_pi(arg1, arg2, arg3)
AP_shift_pi = _CosmoBolognaLib.AP_shift_pi

def max_separations_AP(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8):
    return _CosmoBolognaLib.max_separations_AP(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
max_separations_AP = _CosmoBolognaLib.max_separations_AP

def converted_xi(*args):
    return _CosmoBolognaLib.converted_xi(*args)
converted_xi = _CosmoBolognaLib.converted_xi

def redshift_range(arg1, arg2, arg3, arg4, arg5):
    return _CosmoBolognaLib.redshift_range(arg1, arg2, arg3, arg4, arg5)
redshift_range = _CosmoBolognaLib.redshift_range

def volume(arg1, arg2, arg3, arg4, arg5):
    return _CosmoBolognaLib.volume(arg1, arg2, arg3, arg4, arg5)
volume = _CosmoBolognaLib.volume

def coord_zSpace(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15):
    return _CosmoBolognaLib.coord_zSpace(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15)
coord_zSpace = _CosmoBolognaLib.coord_zSpace

def create_mocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19):
    return _CosmoBolognaLib.create_mocks(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19)
create_mocks = _CosmoBolognaLib.create_mocks

def set_ObjectRegion_SubBoxes(data, random, nx, ny, nz):
    return _CosmoBolognaLib.set_ObjectRegion_SubBoxes(data, random, nx, ny, nz)
set_ObjectRegion_SubBoxes = _CosmoBolognaLib.set_ObjectRegion_SubBoxes

def set_ObjectRegion_RaDec(data, random, Cell_size):
    return _CosmoBolognaLib.set_ObjectRegion_RaDec(data, random, Cell_size)
set_ObjectRegion_RaDec = _CosmoBolognaLib.set_ObjectRegion_RaDec

def set_ObjectRegion_mangle(data, random, nSamples, polygonfile):
    return _CosmoBolognaLib.set_ObjectRegion_mangle(data, random, nSamples, polygonfile)
set_ObjectRegion_mangle = _CosmoBolognaLib.set_ObjectRegion_mangle

def check_regions(data, random):
    return _CosmoBolognaLib.check_regions(data, random)
check_regions = _CosmoBolognaLib.check_regions

def reconstruction_fourier_space(data, random, cosmology, redshift, bias, cell_size, smoothing_radius, interpolation_type=0):
    return _CosmoBolognaLib.reconstruction_fourier_space(data, random, cosmology, redshift, bias, cell_size, smoothing_radius, interpolation_type)
reconstruction_fourier_space = _CosmoBolognaLib.reconstruction_fourier_space

def displaced_catalogue(input_catalogue):
    return _CosmoBolognaLib.displaced_catalogue(input_catalogue)
displaced_catalogue = _CosmoBolognaLib.displaced_catalogue
class ReadParameters(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ReadParameters, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ReadParameters, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CosmoBolognaLib.new_ReadParameters(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CosmoBolognaLib.delete_ReadParameters
    __del__ = lambda self: None
ReadParameters_swigregister = _CosmoBolognaLib.ReadParameters_swigregister
ReadParameters_swigregister(ReadParameters)

# This file is compatible with both classic and new-style classes.


